diff --git a/Rakefile b/Rakefile index 9d866ea..ec3ae04 100644 --- a/Rakefile +++ b/Rakefile @@ -41,17 +41,43 @@ end desc 'Convert previous stage language into the current stage language' task :convert do - File.open('boot/stage14.elna', 'w') do |current_stage| - previous_line = nil + File.open('boot/stage16.elna', 'w') do |current_stage| + skip = false - File.readlines('boot/stage13.elna').each do |line| - if !previous_line.nil? && previous_line.start_with?('begin') && line.strip.start_with?('return') - else - current_stage << previous_line unless previous_line.nil? + File.readlines('boot/stage15.elna').each do |line| + if line.strip == 'type' + current_stage << <<~SNIP + type + _elna_tac_declaration = record + next: Word; + name: Word; + length: Word; + body: Word + end; + _integer_literal_node = record + kind: Word; + value: Word; + length: Word + end; + SNIP + elsif line.start_with?('proc _elna_tac_declaration_size') + skip = true + elsif line.start_with?('proc _elna_tac_declaration_get_') + skip = true + elsif line.start_with?('proc _elna_tac_declaration_set_') + skip = true + elsif line.start_with?('proc _integer_literal_node_size') + skip = true + elsif line.start_with?('proc _integer_literal_node_get_') + skip = true + elsif line.start_with?('proc _integer_literal_node_set_') + skip = true + elsif line.start_with?('end') && skip + skip = false + elsif !skip + current_stage << line end - previous_line = line end - current_stage << previous_line end end diff --git a/boot/stage15.elna b/boot/stage15.elna index c641a62..987d655 100644 --- a/boot/stage15.elna +++ b/boot/stage15.elna @@ -7,7 +7,7 @@ (* Stage 15 compiler. *) type - LexerAction = (none, accumulate, skip, single, eof, finalize, composite, key_id, integer, delimited); + ElnaLexerAction = (none, accumulate, skip, single, eof, finalize, composite, key_id, integer, delimited); (** * Classification table assigns each possible character to a group (class). All @@ -18,7 +18,7 @@ type * next_state: TransitionState * end; *) - LexerClass = ( + ElnaLexerClass = ( invalid, digit, alpha, @@ -42,7 +42,7 @@ type less, other ); - LexerState = ( + ElnaLexerState = ( start, colon, identifier, @@ -61,7 +61,7 @@ type string_escape, finish ); - LexerTokenKind = ( + ElnaLexerKind = ( identifier, _const, _var, @@ -77,7 +77,6 @@ type _do, _extern, _record, - _union, _true, _false, null, @@ -148,10 +147,11 @@ type enumeration_type_expression, named_type_expression, type_declaration, - module_declaration + module_declaration, + record_type_expression ); InfoKind = (type_info, parameter_info, temporary_info, procedure_info); - TypeKind = (primitive, enumeration); + TypeKind = (primitive, enumeration, _record); ElnaTacOperator = ( load_immediate, load_address, @@ -176,8 +176,9 @@ type not, jump, beqz, - ret, - label + label, + start, + ret ); ElnaTacOperand = (register, immediate, symbol, offset); ElnaTacRegister = ( @@ -1101,20 +1102,20 @@ begin elsif instruction_kind = ElnaTacOperator.beqz then argument_count := 2; _write_s("\tbeqz", 5) + elsif instruction_kind = ElnaTacOperator.start then + argument_count := 0; + _write_z("\taddi sp, sp, -128\n\tsw ra, 124(sp)\n\tsw s0, 120(sp)\n\taddi s0, sp, 128\0") elsif instruction_kind = ElnaTacOperator.ret then argument_count := 0; - _write_s("\tret", 4) + _write_z("\tlw ra, 124(sp)\n\tlw s0, 120(sp)\n\taddi sp, sp, 128\0") end; return argument_count end; proc _elna_writer_register(register: Word); -var - number: Word; begin _write_c('x'); - number := register - 1; - _write_i(number) + _write_i(register - 1) end; proc _elna_writer_operand(instruction: Word, n: Word); @@ -1191,18 +1192,6 @@ begin 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; @@ -1224,9 +1213,8 @@ begin _write_s(name_pointer, name_length); _write_z(":\n\0"); - _elna_writer_prologue(); _elna_writer_instructions(body_statements); - _elna_writer_epilogue(); + _write_z("\tret\n\0"); procedure := _elna_tac_declaration_get_next(procedure); if procedure <> 0 then @@ -1335,7 +1323,7 @@ begin this^ := value end; -proc _parse_integer_literal(); +proc _elna_parser_integer_literal(); var integer_token: Word; integer_length: Word; @@ -1345,10 +1333,10 @@ begin literal_size := _integer_literal_node_size(); result := _allocate(literal_size); - integer_token := _lexer_global_get_start(); - integer_length := _lexer_global_get_end(); + integer_token := _elna_lexer_global_get_start(); + integer_length := _elna_lexer_global_get_end(); integer_length := integer_length - integer_token; - _lexer_skip_token(); + _elna_lexer_skip_token(); _node_set_kind(result, NodeKind.integer_literal); _integer_literal_node_set_value(result, integer_token); @@ -1397,7 +1385,7 @@ begin this^ := value end; -proc _parse_character_literal(); +proc _elna_parser_character_literal(); var character: Word; character_length: Word; @@ -1407,10 +1395,10 @@ begin literal_size := _character_literal_node_size(); result := _allocate(literal_size); - character := _lexer_global_get_start(); - character_length := _lexer_global_get_end(); + character := _elna_lexer_global_get_start(); + character_length := _elna_lexer_global_get_end(); character_length := character_length - character; - _lexer_skip_token(); + _elna_lexer_skip_token(); _node_set_kind(result, NodeKind.character_literal); _integer_literal_node_set_value(result, character); @@ -1467,17 +1455,17 @@ begin return result end; -proc _parse_variable_expression(); +proc _elna_parser_variable_expression(); var name: Word; name_token: Word; result: Word; memory_size: Word; begin - name := _lexer_global_get_start(); - name_token := _lexer_global_get_end(); + name := _elna_lexer_global_get_start(); + name_token := _elna_lexer_global_get_end(); name_token := name_token - name; - _lexer_skip_token(); + _elna_lexer_skip_token(); memory_size := _variable_expression_size(); result := _allocate(memory_size); @@ -1536,7 +1524,7 @@ begin this^ := value end; -proc _parse_string_literal(); +proc _elna_parser_string_literal(); var length: Word; token_start: Word; @@ -1546,9 +1534,9 @@ begin memory_size := _string_literal_node_size(); result := _allocate(memory_size); - token_start := _lexer_global_get_start(); + token_start := _elna_lexer_global_get_start(); length := _string_length(token_start); - _lexer_skip_token(); + _elna_lexer_skip_token(); _node_set_kind(result, NodeKind.string_literal); _string_literal_node_set_value(result, token_start); @@ -1579,23 +1567,23 @@ begin return first_instruction end; -proc _parse_simple_expression(); +proc _elna_parser_simple_expression(); var current_character: Word; parser_node: Word; token_kind: Word; begin parser_node := 0; - _lexer_read_token(@token_kind); + _elna_lexer_read_token(@token_kind); - if token_kind = LexerTokenKind.character then - parser_node := _parse_character_literal() - elsif token_kind = LexerTokenKind.integer then - parser_node := _parse_integer_literal() - elsif token_kind = LexerTokenKind.string then - parser_node := _parse_string_literal() - elsif token_kind = LexerTokenKind.identifier then - parser_node := _parse_variable_expression() + if token_kind = ElnaLexerKind.character then + parser_node := _elna_parser_character_literal() + elsif token_kind = ElnaLexerKind.integer then + parser_node := _elna_parser_integer_literal() + elsif token_kind = ElnaLexerKind.string then + parser_node := _elna_parser_string_literal() + elsif token_kind = ElnaLexerKind.identifier then + parser_node := _elna_parser_variable_expression() end; return parser_node end; @@ -1616,7 +1604,7 @@ begin this^ := value end; -proc _parse_dereference_expression(simple_expression: Word); +proc _elna_parser_dereference_expression(simple_expression: Word); var result: Word; memory_size: Word; @@ -1626,26 +1614,26 @@ begin _node_set_kind(result, NodeKind.dereference_expression); _dereference_expression_set_pointer(result, simple_expression); - _lexer_skip_token(); + _elna_lexer_skip_token(); return result end; -proc _parse_designator(); +proc _elna_parser_designator(); var simple_expression: Word; token_kind: Word; begin - simple_expression := _parse_simple_expression(); + simple_expression := _elna_parser_simple_expression(); - _lexer_read_token(@token_kind); + _elna_lexer_read_token(@token_kind); - if token_kind = LexerTokenKind.hat then - simple_expression := _parse_dereference_expression(simple_expression) - elsif token_kind = LexerTokenKind.dot then - simple_expression := _parse_field_access_expression(simple_expression) - elsif token_kind = LexerTokenKind.left_paren then - simple_expression := _parse_call(simple_expression) + if token_kind = ElnaLexerKind.hat then + simple_expression := _elna_parser_dereference_expression(simple_expression) + elsif token_kind = ElnaLexerKind.dot then + simple_expression := _elna_parser_field_access_expression(simple_expression) + elsif token_kind = ElnaLexerKind.left_paren then + simple_expression := _elna_parser_call(simple_expression) end; return simple_expression end; @@ -1700,7 +1688,7 @@ begin this^ := value end; -proc _parse_unary_expression(); +proc _elna_parser_unary_expression(); var token_kind: Word; result: Word; @@ -1708,20 +1696,20 @@ var operand: Word; operator: Word; begin - _lexer_read_token(@token_kind); + _elna_lexer_read_token(@token_kind); operator := 0; - if token_kind = LexerTokenKind.at then + if token_kind = ElnaLexerKind.at then operator := '@' - elsif token_kind = LexerTokenKind.minus then + elsif token_kind = ElnaLexerKind.minus then operator := '-' - elsif token_kind = LexerTokenKind.not then + elsif token_kind = ElnaLexerKind.not then operator := '~' end; if operator <> 0 then - _lexer_skip_token() + _elna_lexer_skip_token() end; - result := _parse_designator(); + result := _elna_parser_designator(); if operator <> 0 then operand := result; @@ -1818,7 +1806,7 @@ begin this^ := value end; -proc _parse_binary_expression(); +proc _elna_parser_binary_expression(); var lhs_node: Word; rhs_node: Word; @@ -1826,52 +1814,52 @@ var memory_size: Word; result: Word; begin - lhs_node := _parse_unary_expression(); + lhs_node := _elna_parser_unary_expression(); rhs_node := 0; - _lexer_read_token(@token_kind); + _elna_lexer_read_token(@token_kind); - if token_kind = LexerTokenKind.plus then - _lexer_skip_token(); - rhs_node := _parse_unary_expression() - elsif token_kind = LexerTokenKind.minus then - _lexer_skip_token(); - rhs_node := _parse_unary_expression() - elsif token_kind = LexerTokenKind.multiplication then - _lexer_skip_token(); - rhs_node := _parse_unary_expression() - elsif token_kind = LexerTokenKind.and then - _lexer_skip_token(); - rhs_node := _parse_unary_expression() - elsif token_kind = LexerTokenKind._or then - _lexer_skip_token(); - rhs_node := _parse_unary_expression() - elsif token_kind = LexerTokenKind._xor then - _lexer_skip_token(); - rhs_node := _parse_unary_expression() - elsif token_kind = LexerTokenKind.equals then - _lexer_skip_token(); - rhs_node := _parse_unary_expression() - elsif token_kind = LexerTokenKind.remainder then - _lexer_skip_token(); - rhs_node := _parse_unary_expression() - elsif token_kind = LexerTokenKind.division then - _lexer_skip_token(); - rhs_node := _parse_unary_expression() - elsif token_kind = LexerTokenKind.less_than then - _lexer_skip_token(); - rhs_node := _parse_unary_expression() - elsif token_kind = LexerTokenKind.greater_than then - _lexer_skip_token(); - rhs_node := _parse_unary_expression() - elsif token_kind = LexerTokenKind.less_equal then - _lexer_skip_token(); - rhs_node := _parse_unary_expression() - elsif token_kind = LexerTokenKind.not_equal then - _lexer_skip_token(); - rhs_node := _parse_unary_expression() - elsif token_kind = LexerTokenKind.greater_equal then - _lexer_skip_token(); - rhs_node := _parse_unary_expression() + if token_kind = ElnaLexerKind.plus then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.minus then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.multiplication then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.and then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind._or then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind._xor then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.equals then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.remainder then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.division then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.less_than then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.greater_than then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.less_equal then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.not_equal then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.greater_equal then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() end; if rhs_node <> 0 then memory_size := _binary_expression_size(); @@ -1921,58 +1909,58 @@ begin _elna_tac_instruction_set_next(current_instruction, instruction); current_instruction := instruction; - if token_kind = LexerTokenKind.plus then + if token_kind = ElnaLexerKind.plus then instruction := _elna_tac_add(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); _elna_tac_instruction_set_next(current_instruction, instruction) - elsif token_kind = LexerTokenKind.minus then + elsif token_kind = ElnaLexerKind.minus then instruction := _elna_tac_sub(ElnaTacRegister.t0, ElnaTacRegister.t1, ElnaTacRegister.t0); _elna_tac_instruction_set_next(current_instruction, instruction) - elsif token_kind = LexerTokenKind.multiplication then + elsif token_kind = ElnaLexerKind.multiplication then instruction := _elna_tac_mul(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); _elna_tac_instruction_set_next(current_instruction, instruction) - elsif token_kind = LexerTokenKind.and then + elsif token_kind = ElnaLexerKind.and then instruction := _elna_tac_and(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); _elna_tac_instruction_set_next(current_instruction, instruction) - elsif token_kind = LexerTokenKind._or then + elsif token_kind = ElnaLexerKind._or then instruction := _elna_tac_or(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); _elna_tac_instruction_set_next(current_instruction, instruction) - elsif token_kind = LexerTokenKind._xor then + elsif token_kind = ElnaLexerKind._xor then instruction := _elna_tac_xor(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); _elna_tac_instruction_set_next(current_instruction, instruction) - elsif token_kind = LexerTokenKind.equals then + elsif token_kind = ElnaLexerKind.equals then instruction := _elna_tac_xor(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); _elna_tac_instruction_set_next(current_instruction, instruction); 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 + elsif token_kind = ElnaLexerKind.remainder then instruction := _elna_tac_rem(ElnaTacRegister.t0, ElnaTacRegister.t1, ElnaTacRegister.t0); _elna_tac_instruction_set_next(current_instruction, instruction) - elsif token_kind = LexerTokenKind.division then + elsif token_kind = ElnaLexerKind.division then 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 + elsif token_kind = ElnaLexerKind.less_than then 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 + elsif token_kind = ElnaLexerKind.greater_than then 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 + elsif token_kind = ElnaLexerKind.less_equal then instruction := _elna_tac_slt(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); _elna_tac_instruction_set_next(current_instruction, instruction); 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 + elsif token_kind = ElnaLexerKind.not_equal then instruction := _elna_tac_xor(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); _elna_tac_instruction_set_next(current_instruction, instruction); 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 + elsif token_kind = ElnaLexerKind.greater_equal then instruction := _elna_tac_slt(ElnaTacRegister.t0, ElnaTacRegister.t1, ElnaTacRegister.t0); _elna_tac_instruction_set_next(current_instruction, instruction); current_instruction := instruction; @@ -2017,7 +2005,7 @@ begin this^ := value end; -proc _parse_call(callee: Word); +proc _elna_parser_call(callee: Word); var parsed_expression: Word; result: Word; @@ -2033,27 +2021,27 @@ begin argument_number := 1; _call_set_name(result, callee); - _lexer_read_token(@token_kind); - _lexer_skip_token(); - _lexer_read_token(@token_kind); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); - if token_kind = LexerTokenKind.right_paren then - _lexer_skip_token(); - goto parse_call_end + if token_kind = ElnaLexerKind.right_paren then + _elna_lexer_skip_token(); + goto elna_parser_call_end end; - .parse_call_loop; - parsed_expression := _parse_binary_expression(); + .elna_parser_call_loop; + parsed_expression := _elna_parser_binary_expression(); _call_set_argument(result, argument_number, parsed_expression); argument_number := argument_number + 1; - _lexer_read_token(@token_kind); - _lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); - if token_kind = LexerTokenKind.comma then - goto parse_call_loop + if token_kind = ElnaLexerKind.comma then + goto elna_parser_call_loop end; - .parse_call_end; + .elna_parser_call_end; (* Set the trailing argument to nil. *) _call_set_argument(result, argument_number, 0); @@ -2171,7 +2159,7 @@ begin this^ := value end; -proc _parse_goto_statement(); +proc _elna_parser_goto_statement(); var token_kind: Word; label_name: Word; @@ -2179,12 +2167,12 @@ var statement_size: Word; result: Word; begin - _lexer_skip_token(); - _lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); - label_name := _lexer_global_get_start(); - label_length := _lexer_global_get_end() - label_name; - _lexer_skip_token(); + label_name := _elna_lexer_global_get_start(); + label_length := _elna_lexer_global_get_end() - label_name; + _elna_lexer_skip_token(); statement_size := _goto_statement_size(); result := _allocate(statement_size); @@ -2242,7 +2230,7 @@ begin this^ := value end; -proc _parse_label_declaration(); +proc _elna_parser_label_declaration(); var token_kind: Word; label_name: Word; @@ -2250,12 +2238,12 @@ var statement_size: Word; result: Word; begin - _lexer_skip_token(); - _lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); - label_name := _lexer_global_get_start(); - label_length := _lexer_global_get_end() - label_name; - _lexer_skip_token(); + label_name := _elna_lexer_global_get_start(); + label_length := _elna_lexer_global_get_end() - label_name; + _elna_lexer_skip_token(); statement_size := _label_declaration_size(); result := _allocate(statement_size); @@ -2363,7 +2351,7 @@ begin members := _enumeration_type_get_members(enumeration_type); members_length := _enumeration_type_get_length(enumeration_type); - _lexer_read_token(@token_type); + _elna_lexer_read_token(@token_type); value_name := _field_access_expression_get_field(field_access_expression); name_length := _field_access_expression_get_length(field_access_expression); @@ -2376,7 +2364,7 @@ begin member_length := members + 4; member_length := member_length^; - if _lexer_compare_keyword(value_name, name_length, member_name, member_length) = 0 then + if _string_compare(value_name, name_length, member_name, member_length) = 0 then members_length := members_length - 1; members := members + 8; counter := counter + 1; @@ -2387,7 +2375,7 @@ begin return instruction end; -proc _parse_field_access_expression(aggregate: Word); +proc _elna_parser_field_access_expression(aggregate: Word); var token_kind: Word; name: Word; @@ -2396,13 +2384,13 @@ var memory_size: Word; begin (* Skip dot. Read the enumeration value. *) - _lexer_skip_token(); - _lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); - name := _lexer_global_get_start(); - name_token := _lexer_global_get_end(); + name := _elna_lexer_global_get_start(); + name_token := _elna_lexer_global_get_end(); name_token := name_token - name; - _lexer_skip_token(); + _elna_lexer_skip_token(); memory_size := _field_access_expression_size(); result := _allocate(memory_size); @@ -2473,7 +2461,7 @@ begin this^ := value end; -proc _parse_assign_statement(assignee: Word); +proc _elna_parser_assign_statement(assignee: Word); var statement_size: Word; result: Word; @@ -2488,10 +2476,10 @@ begin _assign_statement_set_assignee(result, assignee); (* Skip the assignment sign (:=) with surrounding whitespaces. *) - _lexer_read_token(@token_kind); - _lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); - assignment_node := _parse_binary_expression(); + assignment_node := _elna_parser_binary_expression(); _assign_statement_set_assignment(result, assignment_node); return result @@ -2542,7 +2530,7 @@ begin this^ := value end; -proc _parse_return_statement(); +proc _elna_parser_return_statement(); var token_kind: Word; returned: Word; @@ -2551,10 +2539,10 @@ var result: Word; begin (* Skip "return" keyword and whitespace after it. *) - _lexer_skip_token(); - _lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); - returned := _parse_binary_expression(); + returned := _elna_parser_binary_expression(); statement_size := _return_statement_size(); result := _allocate(statement_size); @@ -2601,7 +2589,7 @@ begin end end; -proc _parse_conditional_statements(); +proc _elna_parser_conditional_statements(); var conditional_size: Word; token_kind: Word; @@ -2612,16 +2600,16 @@ begin result := _allocate(conditional_size); (* Skip "if", "while" or "elsif". *) - _lexer_skip_token(); + _elna_lexer_skip_token(); - current_node := _parse_binary_expression(); + current_node := _elna_parser_binary_expression(); _conditional_statements_set_condition(result, current_node); (* Skip "then" or "do". *) - _lexer_read_token(@token_kind); - _lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); - current_node := _parse_statements(); + current_node := _elna_parser_statements(); _conditional_statements_set_statements(result, current_node); _conditional_statements_set_next(result, 0); @@ -2732,7 +2720,7 @@ begin this^ := value end; -proc _parse_if_statement(); +proc _elna_parser_if_statement(); var current_node: Word; result: Word; @@ -2747,58 +2735,58 @@ begin _node_set_kind(result, NodeKind.if_statement); _statement_set_next(result, 0); - previous_conditional := _parse_conditional_statements(); + previous_conditional := _elna_parser_conditional_statements(); _if_statement_set_conditionals(result, previous_conditional); - .parse_if_statement_loop; - _lexer_read_token(@token_kind); + .elna_parser_if_statement_loop; + _elna_lexer_read_token(@token_kind); - if token_kind = LexerTokenKind._elsif then - next_conditional := _parse_conditional_statements(); + if token_kind = ElnaLexerKind._elsif then + next_conditional := _elna_parser_conditional_statements(); _conditional_statements_set_next(previous_conditional, next_conditional); previous_conditional = next_conditional; - goto parse_if_statement_loop - elsif token_kind = LexerTokenKind._else then - _lexer_skip_token(); + goto elna_parser_if_statement_loop + elsif token_kind = ElnaLexerKind._else then + _elna_lexer_skip_token(); - current_node := _parse_statements(); + current_node := _elna_parser_statements(); _if_statement_set_else(result, current_node) else _if_statement_set_else(result, 0) end; - _lexer_skip_token(); + _elna_lexer_skip_token(); return result end; -proc _parse_statement(); +proc _elna_parser_statement(); var token_kind: Word; result : Word; begin result := 0; - _lexer_read_token(@token_kind); + _elna_lexer_read_token(@token_kind); - if token_kind = LexerTokenKind._goto then - result := _parse_goto_statement() - elsif token_kind = LexerTokenKind._if then - result := _parse_if_statement() - elsif token_kind = LexerTokenKind._return then - result := _parse_return_statement() - elsif token_kind = LexerTokenKind.dot then - result := _parse_label_declaration() - elsif token_kind = LexerTokenKind.identifier then - result := _parse_designator(); + if token_kind = ElnaLexerKind._goto then + result := _elna_parser_goto_statement() + elsif token_kind = ElnaLexerKind._if then + result := _elna_parser_if_statement() + elsif token_kind = ElnaLexerKind._return then + result := _elna_parser_return_statement() + elsif token_kind = ElnaLexerKind.dot then + result := _elna_parser_label_declaration() + elsif token_kind = ElnaLexerKind.identifier then + result := _elna_parser_designator(); if _node_get_kind(result) <> NodeKind.call then - result := _parse_assign_statement(result) + result := _elna_parser_assign_statement(result) end end; return result end; -proc _parse_statements(); +proc _elna_parser_statements(); var token_kind: Word; previous_statement: Word; @@ -2807,27 +2795,27 @@ var begin _skip_empty_lines(); - first_statement := _parse_statement(); + first_statement := _elna_parser_statement(); previous_statement := first_statement; if previous_statement = 0 then - goto parse_statements_end + goto elna_parser_statements_end end; - .parse_statement_loop; - _lexer_read_token(@token_kind); + .elna_parser_statement_loop; + _elna_lexer_read_token(@token_kind); - if token_kind = LexerTokenKind.semicolon then - _lexer_skip_token(); + if token_kind = ElnaLexerKind.semicolon then + _elna_lexer_skip_token(); _skip_empty_lines(); - next_statement := _parse_statement(); + next_statement := _elna_parser_statement(); _statement_set_next(previous_statement, next_statement); previous_statement := next_statement; if previous_statement <> 0 then - goto parse_statement_loop + goto elna_parser_statement_loop end end; - .parse_statements_end; + .elna_parser_statements_end; _skip_empty_lines(); return first_statement @@ -2959,6 +2947,10 @@ begin this^ := value end; +proc _enumeration_type_size(); + return 16 +end; + proc _enumeration_type_get_members(this: Word); begin this := this + 8; @@ -3011,6 +3003,62 @@ begin this^ := value end; +proc _record_type_size(); + return 16 +end; + +proc _record_type_get_members(this: Word); +begin + this := this + 8; + return this^ +end; + +proc _record_type_set_members(this: Word, value: Word); +begin + this := this + 8; + this^ := value +end; + +proc _record_type_get_length(this: Word); +begin + this := this + 12; + return this^ +end; + +proc _record_type_set_length(this: Word, value: Word); +begin + this := this + 12; + this^ := value +end; + +proc _record_type_expression_size(); + return 12 +end; + +proc _record_type_expression_get_members(this: Word); +begin + this := this + 4; + return this^ +end; + +proc _record_type_expression_set_members(this: Word, value: Word); +begin + this := this + 4; + this^ := value +end; + +proc _record_type_expression_get_length(this: Word); +begin + this := this + 8; + return this^ +end; + +proc _record_type_expression_set_length(this: Word, value: Word); +begin + this := this + 8; + this^ := value +end; + proc _named_type_expression_size(); return 12 end; @@ -3039,7 +3087,79 @@ begin this^ := value end; -proc _parse_enumeration_type_expression(); +proc _elna_parser_record_type_expression(); +var + entry: Word; + member_count: Word; + memory_start: Word; + field_name: Word; + field_length: Word; + field_type: Word; + token_kind: Word; + type_expression_size: Word; + result: Word; + previous_entry: Word; +begin + _elna_lexer_skip_token(); + member_count := 0; + memory_start := 0; + + _elna_lexer_read_token(@token_kind); + if token_kind = ElnaLexerKind._end then + goto elna_parser_record_type_expression_end + end; + .elna_parser_record_type_expression_loop; + entry := _allocate(16); + member_count := member_count + 1; + + field_name := _elna_lexer_global_get_start(); + field_length := _elna_lexer_global_get_end() - field_name; + + entry^ := field_name; + entry := entry + 4; + + entry^ := field_length; + entry := entry + 4; + + (* Skip the identifier. *) + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + field_type := _elna_parser_type_expression(); + + entry^ := field_type; + entry := entry + 4; + + entry^ := 0; + if memory_start = 0 then + memory_start := entry - 12 + else + previous_entry^ := entry - 12 + end; + previous_entry := entry; + + _elna_lexer_read_token(@token_kind); + if token_kind = ElnaLexerKind.semicolon then + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + goto elna_parser_record_type_expression_loop + end; + + .elna_parser_record_type_expression_end; + _elna_lexer_skip_token(); + + type_expression_size := _enumeration_type_expression_size(); + result := _allocate(type_expression_size); + + _node_set_kind(result, NodeKind.record_type_expression); + _record_type_expression_set_members(result, memory_start); + _record_type_expression_set_length(result, member_count); + + return result +end; + +proc _elna_parser_enumeration_type_expression(); var token_kind: Word; enumeration_name: Word; @@ -3051,20 +3171,20 @@ var entry: Word; previous_entry: Word; begin - _lexer_skip_token(); + _elna_lexer_skip_token(); memory_start := 0; member_count := 0; - _lexer_read_token(@token_kind); - if token_kind = LexerTokenKind.right_paren then - goto parse_enumeration_type_expression_end + _elna_lexer_read_token(@token_kind); + if token_kind = ElnaLexerKind.right_paren then + goto elna_parser_enumeration_type_expression_end end; - .parse_enumeration_type_expression_loop; + .elna_parser_enumeration_type_expression_loop; entry := _allocate(12); member_count := member_count + 1; - enumeration_name := _lexer_global_get_start(); - name_length := _lexer_global_get_end() - enumeration_name; + enumeration_name := _elna_lexer_global_get_start(); + name_length := _elna_lexer_global_get_end() - enumeration_name; entry^ := enumeration_name; entry := entry + 4; @@ -3081,17 +3201,17 @@ begin previous_entry := entry; (* Skip the identifier. *) - _lexer_skip_token(); + _elna_lexer_skip_token(); - _lexer_read_token(@token_kind); - if token_kind = LexerTokenKind.comma then - _lexer_skip_token(); - _lexer_read_token(@token_kind); - goto parse_enumeration_type_expression_loop + _elna_lexer_read_token(@token_kind); + if token_kind = ElnaLexerKind.comma then + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + goto elna_parser_enumeration_type_expression_loop end; - .parse_enumeration_type_expression_end; - _lexer_skip_token(); + .elna_parser_enumeration_type_expression_end; + _elna_lexer_skip_token(); type_expression_size := _enumeration_type_expression_size(); result := _allocate(type_expression_size); @@ -3124,8 +3244,8 @@ var member_array_start: Word; member_array_current: Word; begin - (* The resulting structure is 16 bytes long. *) - result := _allocate(16); + member_array_size := _enumeration_type_size(); + result := _allocate(member_array_size); memory_start := _enumeration_type_expression_get_members(parser_node); member_count := _enumeration_type_expression_get_length(parser_node); @@ -3159,7 +3279,54 @@ begin return _type_info_create(result) end; -proc _parse_named_type_expression(); +proc _elna_name_type_record(parser_node: Word); +var + result: Word; + memory_start: Word; + member_count: Word; + member_array_size: Word; + member_array_start: Word; + member_array_current: Word; +begin + member_array_size := _record_type_size(); + result := _allocate(member_array_size); + + memory_start := _record_type_expression_get_members(parser_node); + member_count := _record_type_expression_get_length(parser_node); + + member_array_size := member_count * 12; + member_array_start := _allocate(member_array_size); + member_array_current := member_array_start; + + .elna_name_type_record_loop; + if member_count > 0 then + member_array_current^ := memory_start^; + member_array_current := member_array_current + 4; + memory_start := memory_start + 4; + + member_array_current^ := memory_start^; + member_array_current := member_array_current + 4; + memory_start := memory_start + 4; + + member_array_current^ := _elna_name_type_expression(memory_start^); + member_array_current := member_array_current + 4; + memory_start := memory_start + 4; + + memory_start := memory_start^; + member_count := member_count - 1; + goto elna_name_type_record_loop + end; + member_count := _record_type_expression_get_length(parser_node); + + _type_set_kind(result, TypeKind._record); + _type_set_size(result, member_count * 4); + _record_type_set_members(result, member_array_start); + _record_type_set_length(result, member_count); + + return _type_info_create(result) +end; + +proc _elna_parser_named_type_expression(); var type_expression_size: Word; result: Word; @@ -3170,27 +3337,29 @@ begin result := _allocate(type_expression_size); _node_set_kind(result, NodeKind.named_type_expression); - type_name := _lexer_global_get_start(); - name_length := _lexer_global_get_end() - type_name; + type_name := _elna_lexer_global_get_start(); + name_length := _elna_lexer_global_get_end() - type_name; _named_type_expression_set_name(result, type_name); _named_type_expression_set_length(result, name_length); - _lexer_skip_token(); + _elna_lexer_skip_token(); return result end; -proc _parse_type_expression(); +proc _elna_parser_type_expression(); var token_kind: Word; result: Word; begin result := 0; - _lexer_read_token(@token_kind); + _elna_lexer_read_token(@token_kind); - if token_kind = LexerTokenKind.identifier then - result := _parse_named_type_expression() - elsif token_kind = LexerTokenKind.left_paren then - result := _parse_enumeration_type_expression() + if token_kind = ElnaLexerKind.identifier then + result := _elna_parser_named_type_expression() + elsif token_kind = ElnaLexerKind.left_paren then + result := _elna_parser_enumeration_type_expression() + elsif token_kind = ElnaLexerKind._record then + result := _elna_parser_record_type_expression() end; return result end; @@ -3212,6 +3381,8 @@ begin result := _type_info_get_type(result) elsif token_kind = NodeKind.enumeration_type_expression then result := _elna_name_type_enumeration(parser_node) + elsif token_kind = NodeKind.record_type_expression then + result := _elna_name_type_record(parser_node) end; return result @@ -3354,16 +3525,13 @@ begin temporary_counter := 0; .elna_name_procedure_temporaries_loop; - if parser_node = 0 then - goto elna_name_procedure_temporaries_end - end; - _elna_name_procedure_temporary(parser_node, temporary_counter, symbol_table); + if parser_node <> 0 then + _elna_name_procedure_temporary(parser_node, temporary_counter, symbol_table); - temporary_counter := temporary_counter + 1; - parser_node := _declaration_get_next(parser_node); - goto elna_name_procedure_temporaries_loop; - - .elna_name_procedure_temporaries_end + temporary_counter := temporary_counter + 1; + parser_node := _declaration_get_next(parser_node); + goto elna_name_procedure_temporaries_loop + end end; proc _declaration_get_next(this: Word); @@ -3443,7 +3611,7 @@ begin this^ := value end; -proc _parse_procedure_declaration(); +proc _elna_parser_procedure_declaration(); var name_pointer: Word; name_length: Word; @@ -3459,27 +3627,27 @@ begin _declaration_set_next(result, 0); (* Skip "proc ". *) - _lexer_skip_token(); + _elna_lexer_skip_token(); - _lexer_read_token(@token_kind); - name_pointer := _lexer_global_get_start(); - name_length := _lexer_global_get_end() - name_pointer; + _elna_lexer_read_token(@token_kind); + name_pointer := _elna_lexer_global_get_start(); + name_length := _elna_lexer_global_get_end() - name_pointer; _declaration_set_name(result, name_pointer); _declaration_set_length(result, name_length); (* Skip procedure name. *) - _lexer_skip_token(); + _elna_lexer_skip_token(); (* Skip open paren. *) - _lexer_read_token(@token_kind); - _lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); parameter_head := 0; - .parse_procedure_declaration_parameter; - _lexer_read_token(@token_kind); + .elna_parser_procedure_declaration_parameter; + _elna_lexer_read_token(@token_kind); - if token_kind <> LexerTokenKind.right_paren then - name_pointer := _parse_variable_declaration(); + if token_kind <> ElnaLexerKind.right_paren then + name_pointer := _elna_parser_variable_declaration(); if parameter_head = 0 then parameter_head := name_pointer else @@ -3487,73 +3655,55 @@ begin end; name_length := name_pointer; - _lexer_read_token(@token_kind); + _elna_lexer_read_token(@token_kind); - if token_kind = LexerTokenKind.comma then - _lexer_skip_token(); - goto parse_procedure_declaration_parameter + if token_kind = ElnaLexerKind.comma then + _elna_lexer_skip_token(); + goto elna_parser_procedure_declaration_parameter end end; (* Skip close paren. *) - _lexer_skip_token(); + _elna_lexer_skip_token(); _procedure_declaration_set_parameters(result, parameter_head); (* Skip semicolon and newline. *) - _lexer_read_token(@token_kind); - _lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); - parameter_head := _parse_var_part(); + parameter_head := _elna_parser_var_part(); _procedure_declaration_set_temporaries(result, parameter_head); (* Skip semicolon, "begin" and newline. *) - _lexer_read_token(@token_kind); - if token_kind = LexerTokenKind._begin then - _lexer_skip_token(); - parameter_head := _parse_statements() - elsif token_kind = LexerTokenKind._return then - parameter_head := _parse_return_statement() + _elna_lexer_read_token(@token_kind); + if token_kind = ElnaLexerKind._begin then + _elna_lexer_skip_token(); + parameter_head := _elna_parser_statements() + elsif token_kind = ElnaLexerKind._return then + parameter_head := _elna_parser_return_statement() end; _procedure_declaration_set_body(result, parameter_head); (* Skip the "end" keyword. *) - _lexer_read_token(@token_kind); - _lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); return result end; -proc _elna_tac_procedure_declaration(parser_node: Word); +proc _elna_tac_parameters(current_parameter: Word, new_symbol_table: Word); var name_pointer: Word; name_length: Word; parameter_counter: Word; - current_parameter: Word; - new_symbol_table: Word; - symbol_info: Word; instruction: Word; first_instruction: Word; current_instruction: Word; - result: Word; - result_size: Word; + symbol_info: Word; begin - result_size := _elna_tac_declaration_size(); - result := _allocate(result_size); - - _elna_tac_declaration_set_next(result, 0); - - name_pointer := _declaration_get_name(parser_node); - name_length := _declaration_get_length(parser_node); - - _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); - - current_parameter := _procedure_declaration_get_parameters(parser_node); first_instruction := 0; parameter_counter := 0; - .elna_tac_procedure_declaration_parameters; + + .elna_tac_parameters_loop; if current_parameter <> 0 then name_pointer := _declaration_get_name(current_parameter); name_length := _declaration_get_length(current_parameter); @@ -3573,22 +3723,59 @@ begin parameter_counter := parameter_counter + 1; current_parameter := _declaration_get_next(current_parameter); - goto elna_tac_procedure_declaration_parameters + goto elna_tac_parameters_loop end; - current_parameter := _procedure_declaration_get_body(parser_node); + return first_instruction +end; + +proc _elna_tac_procedure_declaration(parser_node: Word); +var + name_pointer: Word; + name_length: Word; + current_parameter: Word; + body: Word; + new_symbol_table: Word; + symbol_info: Word; + instruction: Word; + first_instruction: Word; + result: Word; + result_size: Word; +begin + result_size := _elna_tac_declaration_size(); + result := _allocate(result_size); + + _elna_tac_declaration_set_next(result, 0); + + name_pointer := _declaration_get_name(parser_node); + name_length := _declaration_get_length(parser_node); + + _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_tac_instruction_create(ElnaTacOperator.start); + + current_parameter := _procedure_declaration_get_parameters(parser_node); + current_parameter := _elna_tac_parameters(current_parameter, new_symbol_table); + _elna_tac_instruction_set_next(first_instruction, current_parameter); + + body := _procedure_declaration_get_body(parser_node); + instruction := _elna_tac_statements(body, new_symbol_table); + _elna_tac_instruction_set_next(first_instruction, instruction); + + (* Write the epilogue. *) + instruction := _elna_tac_instruction_create(ElnaTacOperator.ret); + _elna_tac_instruction_set_next(first_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; _elna_tac_declaration_set_body(result, first_instruction); return result end; -proc _parse_procedures(); +proc _elna_parser_procedures(); var parser_node: Word; result: Word; @@ -3597,12 +3784,12 @@ var begin result := 0; - .parse_procedures_loop; + .elna_parser_procedures_loop; _skip_empty_lines(); - _lexer_read_token(@token_kind); + _elna_lexer_read_token(@token_kind); - if token_kind = LexerTokenKind._proc then - parser_node := _parse_procedure_declaration(); + if token_kind = ElnaLexerKind._proc then + parser_node := _elna_parser_procedure_declaration(); if result = 0 then result := parser_node else @@ -3611,10 +3798,10 @@ begin current_declaration := parser_node; (* Skip semicolon. *) - _lexer_read_token(@token_kind); - _lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); - goto parse_procedures_loop + goto elna_parser_procedures_loop end; return result end; @@ -3655,10 +3842,10 @@ var begin .skip_empty_lines_rerun; - _lexer_read_token(@token_kind); + _elna_lexer_read_token(@token_kind); - if token_kind = LexerTokenKind.comment then - _lexer_skip_token(); + if token_kind = ElnaLexerKind.comment then + _elna_lexer_skip_token(); goto skip_empty_lines_rerun end end; @@ -3680,7 +3867,7 @@ begin this^ := value end; -proc _parse_type_declaration(); +proc _elna_parser_type_declaration(); var token_kind: Word; type_name: Word; @@ -3689,15 +3876,15 @@ var result: Word; declaration_size: Word; begin - _lexer_read_token(@token_kind); - type_name := _lexer_global_get_start(); - name_length := _lexer_global_get_end() - type_name; + _elna_lexer_read_token(@token_kind); + type_name := _elna_lexer_global_get_start(); + name_length := _elna_lexer_global_get_end() - type_name; - _lexer_skip_token(); - _lexer_read_token(@token_kind); - _lexer_skip_token(); + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); - parser_node := _parse_type_expression(); + parser_node := _elna_parser_type_expression(); declaration_size := _type_declaration_size(); result := _allocate(declaration_size); @@ -3707,8 +3894,8 @@ begin _declaration_set_length(result, name_length); _type_declaration_set_type(result, parser_node); - _lexer_read_token(@token_kind); - _lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); return result end; @@ -3732,7 +3919,7 @@ proc _elna_type_type_declaration(parser_node: Word); begin end; -proc _parse_type_part(); +proc _elna_parser_type_part(); var token_kind: Word; parser_node: Word; @@ -3741,19 +3928,19 @@ var begin result := 0; _skip_empty_lines(); - _lexer_read_token(@token_kind); + _elna_lexer_read_token(@token_kind); - if token_kind <> LexerTokenKind._type then - goto parse_type_part_end + if token_kind <> ElnaLexerKind._type then + goto elna_parser_type_part_end end; - _lexer_skip_token(); + _elna_lexer_skip_token(); - .parse_type_part_loop; + .elna_parser_type_part_loop; _skip_empty_lines(); - _lexer_read_token(@token_kind); - if token_kind = LexerTokenKind.identifier then - parser_node := _parse_type_declaration(); + _elna_lexer_read_token(@token_kind); + if token_kind = ElnaLexerKind.identifier then + parser_node := _elna_parser_type_declaration(); if result = 0 then result := parser_node @@ -3761,10 +3948,10 @@ begin _declaration_set_next(current_declaration, parser_node) end; current_declaration := parser_node; - goto parse_type_part_loop + goto elna_parser_type_part_loop end; - .parse_type_part_end; + .elna_parser_type_part_end; return result end; @@ -3784,7 +3971,7 @@ begin this^ := value end; -proc _parse_variable_declaration(); +proc _elna_parser_variable_declaration(); var token_kind: Word; name: Word; @@ -3793,16 +3980,16 @@ var result: Word; declaration_size: Word; begin - _lexer_read_token(@token_kind); + _elna_lexer_read_token(@token_kind); - name := _lexer_global_get_start(); - name_length := _lexer_global_get_end() - name; + name := _elna_lexer_global_get_start(); + name_length := _elna_lexer_global_get_end() - name; (* Skip the variable name and colon with the type. *) - _lexer_skip_token(); - _lexer_read_token(@token_kind); - _lexer_skip_token(); - variable_type := _parse_type_expression(); + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + variable_type := _elna_parser_type_expression(); declaration_size := _variable_declaration_size(); result := _allocate(declaration_size); @@ -3839,7 +4026,7 @@ begin 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 + if _string_compare("Array", 5, name, name_length) then (* Else we assume this is a zeroed 4096 bytes big array. *) _elna_tac_declaration_set_body(result, 4096) else @@ -3848,7 +4035,170 @@ begin return result end; -proc _parse_var_part(); +proc _elna_tac_type_field(name_pointer: Word, name_length: Word, field_pointer: Word, field_offset: Word); +var + result_size: Word; + first_result: Word; + second_result: Word; + new_name: Word; + new_length: Word; + field_length: Word; + instruction: Word; + name_target: Word; + next_instruction: Word; +begin + result_size := _elna_tac_declaration_size(); + field_length := field_pointer + 4; + field_length := field_length^; + new_length := field_length + name_length; + new_length := new_length + 5; + + first_result := _allocate(result_size); + _elna_tac_declaration_set_next(first_result, 0); + + new_name := _allocate(new_length); + + name_target := new_name; + _memcpy(name_target, name_pointer, name_length); + name_target := name_target + name_length; + _memcpy(name_target, "_get_", 5); + name_target := name_target + 5; + _memcpy(name_target, field_pointer^, field_length); + + _elna_tac_declaration_set_name(first_result, new_name); + _elna_tac_declaration_set_length(first_result, new_length); + + instruction := _elna_tac_add_immediate(ElnaTacRegister.a0, ElnaTacRegister.a0, field_offset, 0); + next_instruction := _elna_tac_load_word(ElnaTacRegister.a0, ElnaTacRegister.a0, 0); + _elna_tac_instruction_set_next(instruction, next_instruction); + _elna_tac_declaration_set_body(first_result, instruction); + + second_result := _allocate(result_size); + _elna_tac_declaration_set_next(second_result, 0); + + new_name := _allocate(new_length); + + name_target := new_name; + _memcpy(name_target, name_pointer, name_length); + name_target := name_target + name_length; + _memcpy(name_target, "_set_", 5); + name_target := name_target + 5; + _memcpy(name_target, field_pointer^, field_length); + + _elna_tac_declaration_set_name(second_result, new_name); + _elna_tac_declaration_set_length(second_result, new_length); + + instruction := _elna_tac_add_immediate(ElnaTacRegister.a0, ElnaTacRegister.a0, field_offset, 0); + next_instruction := _elna_tac_store_word(ElnaTacRegister.a1, ElnaTacRegister.a0, 0); + _elna_tac_instruction_set_next(instruction, next_instruction); + _elna_tac_declaration_set_body(second_result, instruction); + + _elna_tac_declaration_set_next(first_result, second_result); + + return first_result +end; + +proc _elna_tac_type_record(name_pointer: Word, name_length: Word, type_representation: Word, current_result: Word); +var + result_size: Word; + first_result: Word; + result: Word; + type_size: Word; + new_name: Word; + new_length: Word; + instruction: Word; + field_count: Word; + field_offset: Word; + field_pointer: Word; +begin + result_size := _elna_tac_declaration_size(); + first_result := _allocate(result_size); + result := 0; + + (* Debug. Error stream output. + _syscall(2, name_pointer, name_length, 0, 0, 0, 64); *) + + type_size := _type_get_size(type_representation); + new_length := name_length + 5; + new_name := _allocate(new_length); + + _memcpy(new_name, name_pointer, name_length); + _memcpy(new_name + name_length, "_size", 5); + + _elna_tac_declaration_set_name(first_result, new_name); + _elna_tac_declaration_set_length(first_result, new_length); + + instruction := _elna_tac_load_immediate(ElnaTacRegister.a0, type_size, 0); + _elna_tac_declaration_set_body(first_result, instruction); + + field_count := _record_type_get_length(type_representation); + field_pointer := _record_type_get_members(type_representation); + field_offset := 0; + current_result^ := first_result; + + .elna_tac_type_record_fields; + if field_count > 0 then + result := _elna_tac_type_field(name_pointer, name_length, field_pointer, field_offset); + + _elna_tac_declaration_set_next(current_result^, result); + current_result^ := _elna_tac_declaration_get_next(result); + + field_offset := field_offset + 4; + field_count := field_count - 1; + field_pointer := field_pointer + 12; + goto elna_tac_type_record_fields + end; + + return first_result +end; + +proc _elna_tac_type_part(parser_node: Word); +var + name_pointer: Word; + name_length: Word; + result: Word; + first_result: Word; + symbol: Word; + info_type: Word; + type_kind: Word; + current_result: Word; + out_result: Word; +begin + first_result := 0; + + .elna_tac_type_part_loop; + if parser_node = 0 then + goto elna_tac_type_part_end + end; + + name_pointer := _declaration_get_name(parser_node); + name_length := _declaration_get_length(parser_node); + symbol := _symbol_table_lookup(@symbol_table_global, name_pointer, name_length); + + info_type := _type_info_get_type(symbol); + type_kind := _type_get_kind(info_type); + + if type_kind = TypeKind._record then + result := _elna_tac_type_record(name_pointer, name_length, info_type, @out_result) + else + result := 0; + out_result := 0 + end; + if first_result = 0 then + first_result := result; + current_result := out_result + elsif result <> 0 then + _elna_tac_declaration_set_next(current_result, result); + current_result := out_result + end; + parser_node := _declaration_get_next(parser_node); + goto elna_tac_type_part_loop; + + .elna_tac_type_part_end; + return first_result +end; + +proc _elna_parser_var_part(); var result: Word; token_kind: Word; @@ -3856,24 +4206,24 @@ var current_declaration: Word; begin result := 0; - _lexer_read_token(@token_kind); + _elna_lexer_read_token(@token_kind); - if token_kind <> LexerTokenKind._var then - goto parse_var_part_end + if token_kind <> ElnaLexerKind._var then + goto elna_parser_var_part_end end; (* Skip "var". *) - _lexer_skip_token(); + _elna_lexer_skip_token(); - .parse_var_part_loop; + .elna_parser_var_part_loop; _skip_empty_lines(); - _lexer_read_token(@token_kind); + _elna_lexer_read_token(@token_kind); - if token_kind = LexerTokenKind.identifier then - variable_node := _parse_variable_declaration(); + if token_kind = ElnaLexerKind.identifier then + variable_node := _elna_parser_variable_declaration(); (* Skip semicolon. *) - _lexer_read_token(@token_kind); - _lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); if result = 0 then result := variable_node @@ -3881,10 +4231,10 @@ begin _declaration_set_next(current_declaration, variable_node) end; current_declaration := variable_node; - goto parse_var_part_loop + goto elna_parser_var_part_loop end; - .parse_var_part_end; + .elna_parser_var_part_end; return result end; @@ -3957,7 +4307,7 @@ begin this^ := value end; -proc _parse_module_declaration(); +proc _elna_parser_module_declaration(); var parser_node: Word; declaration_size: Word; @@ -3968,13 +4318,13 @@ begin _node_set_kind(result, NodeKind.module_declaration); - parser_node := _parse_type_part(); + parser_node := _elna_parser_type_part(); _module_declaration_set_types(result, parser_node); - parser_node := _parse_var_part(); + parser_node := _elna_parser_var_part(); _module_declaration_set_globals(result, parser_node); - parser_node := _parse_procedures(); + parser_node := _elna_parser_procedures(); _module_declaration_set_procedures(result, parser_node); return result @@ -3987,13 +4337,30 @@ proc _elna_tac_module_declaration(parser_node: Word); var data_part: Word; code_part: Word; + type_part: Word; + current_declaration: Word; + next_declaration: Word; begin + type_part := _module_declaration_get_types(parser_node); + type_part := _elna_tac_type_part(type_part); + data_part := _module_declaration_get_globals(parser_node); data_part := _elna_tac_var_part(data_part); code_part := _module_declaration_get_procedures(parser_node); code_part := _elna_tac_procedures(code_part); + current_declaration := code_part; + + .elna_tac_module_declaration_types; + next_declaration := _elna_tac_declaration_get_next(current_declaration); + if next_declaration <> 0 then + current_declaration := next_declaration; + + goto elna_tac_module_declaration_types + end; + _elna_tac_declaration_set_next(current_declaration, type_part); + return _elna_tac_module_create(data_part, code_part) end; @@ -4084,7 +4451,7 @@ var parser_node: Word; tac: Word; begin - parser_node := _parse_module_declaration(); + parser_node := _elna_parser_module_declaration(); _elna_name_module_declaration(parser_node); _elna_type_module_declaration(parser_node); tac := _elna_tac_module_declaration(parser_node); @@ -4270,144 +4637,144 @@ end; (** * Initializes the array with character classes. *) -proc _lexer_classifications(); +proc _elna_lexer_classifications(); var code: Word; begin - _assign_at(@classification, 1, LexerClass.eof); - _assign_at(@classification, 2, LexerClass.invalid); - _assign_at(@classification, 3, LexerClass.invalid); - _assign_at(@classification, 4, LexerClass.invalid); - _assign_at(@classification, 5, LexerClass.invalid); - _assign_at(@classification, 6, LexerClass.invalid); - _assign_at(@classification, 7, LexerClass.invalid); - _assign_at(@classification, 8, LexerClass.invalid); - _assign_at(@classification, 9, LexerClass.invalid); - _assign_at(@classification, 10, LexerClass.space); - _assign_at(@classification, 11, LexerClass.space); - _assign_at(@classification, 12, LexerClass.invalid); - _assign_at(@classification, 13, LexerClass.invalid); - _assign_at(@classification, 14, LexerClass.space); - _assign_at(@classification, 15, LexerClass.invalid); - _assign_at(@classification, 16, LexerClass.invalid); - _assign_at(@classification, 17, LexerClass.invalid); - _assign_at(@classification, 18, LexerClass.invalid); - _assign_at(@classification, 19, LexerClass.invalid); - _assign_at(@classification, 20, LexerClass.invalid); - _assign_at(@classification, 21, LexerClass.invalid); - _assign_at(@classification, 22, LexerClass.invalid); - _assign_at(@classification, 23, LexerClass.invalid); - _assign_at(@classification, 24, LexerClass.invalid); - _assign_at(@classification, 25, LexerClass.invalid); - _assign_at(@classification, 26, LexerClass.invalid); - _assign_at(@classification, 27, LexerClass.invalid); - _assign_at(@classification, 28, LexerClass.invalid); - _assign_at(@classification, 29, LexerClass.invalid); - _assign_at(@classification, 30, LexerClass.invalid); - _assign_at(@classification, 31, LexerClass.invalid); - _assign_at(@classification, 32, LexerClass.invalid); - _assign_at(@classification, 33, LexerClass.space); - _assign_at(@classification, 34, LexerClass.single); - _assign_at(@classification, 35, LexerClass.double_quote); - _assign_at(@classification, 36, LexerClass.other); - _assign_at(@classification, 37, LexerClass.other); - _assign_at(@classification, 38, LexerClass.single); - _assign_at(@classification, 39, LexerClass.single); - _assign_at(@classification, 40, LexerClass.single_quote); - _assign_at(@classification, 41, LexerClass.left_paren); - _assign_at(@classification, 42, LexerClass.right_paren); - _assign_at(@classification, 43, LexerClass.asterisk); - _assign_at(@classification, 44, LexerClass.single); - _assign_at(@classification, 45, LexerClass.single); - _assign_at(@classification, 46, LexerClass.minus); - _assign_at(@classification, 47, LexerClass.dot); - _assign_at(@classification, 48, LexerClass.single); - _assign_at(@classification, 49, LexerClass.zero); - _assign_at(@classification, 50, LexerClass.digit); - _assign_at(@classification, 51, LexerClass.digit); - _assign_at(@classification, 52, LexerClass.digit); - _assign_at(@classification, 53, LexerClass.digit); - _assign_at(@classification, 54, LexerClass.digit); - _assign_at(@classification, 55, LexerClass.digit); - _assign_at(@classification, 56, LexerClass.digit); - _assign_at(@classification, 57, LexerClass.digit); - _assign_at(@classification, 58, LexerClass.digit); - _assign_at(@classification, 59, LexerClass.colon); - _assign_at(@classification, 60, LexerClass.single); - _assign_at(@classification, 61, LexerClass.less); - _assign_at(@classification, 62, LexerClass.equals); - _assign_at(@classification, 63, LexerClass.greater); - _assign_at(@classification, 64, LexerClass.other); - _assign_at(@classification, 65, LexerClass.single); - _assign_at(@classification, 66, LexerClass.alpha); - _assign_at(@classification, 67, LexerClass.alpha); - _assign_at(@classification, 68, LexerClass.alpha); - _assign_at(@classification, 69, LexerClass.alpha); - _assign_at(@classification, 70, LexerClass.alpha); - _assign_at(@classification, 71, LexerClass.alpha); - _assign_at(@classification, 72, LexerClass.alpha); - _assign_at(@classification, 73, LexerClass.alpha); - _assign_at(@classification, 74, LexerClass.alpha); - _assign_at(@classification, 75, LexerClass.alpha); - _assign_at(@classification, 76, LexerClass.alpha); - _assign_at(@classification, 77, LexerClass.alpha); - _assign_at(@classification, 78, LexerClass.alpha); - _assign_at(@classification, 79, LexerClass.alpha); - _assign_at(@classification, 80, LexerClass.alpha); - _assign_at(@classification, 81, LexerClass.alpha); - _assign_at(@classification, 82, LexerClass.alpha); - _assign_at(@classification, 83, LexerClass.alpha); - _assign_at(@classification, 84, LexerClass.alpha); - _assign_at(@classification, 85, LexerClass.alpha); - _assign_at(@classification, 86, LexerClass.alpha); - _assign_at(@classification, 87, LexerClass.alpha); - _assign_at(@classification, 88, LexerClass.alpha); - _assign_at(@classification, 89, LexerClass.alpha); - _assign_at(@classification, 90, LexerClass.alpha); - _assign_at(@classification, 91, LexerClass.alpha); - _assign_at(@classification, 92, LexerClass.single); - _assign_at(@classification, 93, LexerClass.backslash); - _assign_at(@classification, 94, LexerClass.single); - _assign_at(@classification, 95, LexerClass.single); - _assign_at(@classification, 96, LexerClass.alpha); - _assign_at(@classification, 97, LexerClass.other); - _assign_at(@classification, 98, LexerClass.hex); - _assign_at(@classification, 99, LexerClass.hex); - _assign_at(@classification, 100, LexerClass.hex); - _assign_at(@classification, 101, LexerClass.hex); - _assign_at(@classification, 102, LexerClass.hex); - _assign_at(@classification, 103, LexerClass.hex); - _assign_at(@classification, 104, LexerClass.alpha); - _assign_at(@classification, 105, LexerClass.alpha); - _assign_at(@classification, 106, LexerClass.alpha); - _assign_at(@classification, 107, LexerClass.alpha); - _assign_at(@classification, 108, LexerClass.alpha); - _assign_at(@classification, 109, LexerClass.alpha); - _assign_at(@classification, 110, LexerClass.alpha); - _assign_at(@classification, 111, LexerClass.alpha); - _assign_at(@classification, 112, LexerClass.alpha); - _assign_at(@classification, 113, LexerClass.alpha); - _assign_at(@classification, 114, LexerClass.alpha); - _assign_at(@classification, 115, LexerClass.alpha); - _assign_at(@classification, 116, LexerClass.alpha); - _assign_at(@classification, 117, LexerClass.alpha); - _assign_at(@classification, 118, LexerClass.alpha); - _assign_at(@classification, 119, LexerClass.alpha); - _assign_at(@classification, 120, LexerClass.alpha); - _assign_at(@classification, 121, LexerClass.x); - _assign_at(@classification, 122, LexerClass.alpha); - _assign_at(@classification, 123, LexerClass.alpha); - _assign_at(@classification, 124, LexerClass.other); - _assign_at(@classification, 125, LexerClass.single); - _assign_at(@classification, 126, LexerClass.other); - _assign_at(@classification, 127, LexerClass.single); - _assign_at(@classification, 128, LexerClass.invalid); + _assign_at(@classification, 1, ElnaLexerClass.eof); + _assign_at(@classification, 2, ElnaLexerClass.invalid); + _assign_at(@classification, 3, ElnaLexerClass.invalid); + _assign_at(@classification, 4, ElnaLexerClass.invalid); + _assign_at(@classification, 5, ElnaLexerClass.invalid); + _assign_at(@classification, 6, ElnaLexerClass.invalid); + _assign_at(@classification, 7, ElnaLexerClass.invalid); + _assign_at(@classification, 8, ElnaLexerClass.invalid); + _assign_at(@classification, 9, ElnaLexerClass.invalid); + _assign_at(@classification, 10, ElnaLexerClass.space); + _assign_at(@classification, 11, ElnaLexerClass.space); + _assign_at(@classification, 12, ElnaLexerClass.invalid); + _assign_at(@classification, 13, ElnaLexerClass.invalid); + _assign_at(@classification, 14, ElnaLexerClass.space); + _assign_at(@classification, 15, ElnaLexerClass.invalid); + _assign_at(@classification, 16, ElnaLexerClass.invalid); + _assign_at(@classification, 17, ElnaLexerClass.invalid); + _assign_at(@classification, 18, ElnaLexerClass.invalid); + _assign_at(@classification, 19, ElnaLexerClass.invalid); + _assign_at(@classification, 20, ElnaLexerClass.invalid); + _assign_at(@classification, 21, ElnaLexerClass.invalid); + _assign_at(@classification, 22, ElnaLexerClass.invalid); + _assign_at(@classification, 23, ElnaLexerClass.invalid); + _assign_at(@classification, 24, ElnaLexerClass.invalid); + _assign_at(@classification, 25, ElnaLexerClass.invalid); + _assign_at(@classification, 26, ElnaLexerClass.invalid); + _assign_at(@classification, 27, ElnaLexerClass.invalid); + _assign_at(@classification, 28, ElnaLexerClass.invalid); + _assign_at(@classification, 29, ElnaLexerClass.invalid); + _assign_at(@classification, 30, ElnaLexerClass.invalid); + _assign_at(@classification, 31, ElnaLexerClass.invalid); + _assign_at(@classification, 32, ElnaLexerClass.invalid); + _assign_at(@classification, 33, ElnaLexerClass.space); + _assign_at(@classification, 34, ElnaLexerClass.single); + _assign_at(@classification, 35, ElnaLexerClass.double_quote); + _assign_at(@classification, 36, ElnaLexerClass.other); + _assign_at(@classification, 37, ElnaLexerClass.other); + _assign_at(@classification, 38, ElnaLexerClass.single); + _assign_at(@classification, 39, ElnaLexerClass.single); + _assign_at(@classification, 40, ElnaLexerClass.single_quote); + _assign_at(@classification, 41, ElnaLexerClass.left_paren); + _assign_at(@classification, 42, ElnaLexerClass.right_paren); + _assign_at(@classification, 43, ElnaLexerClass.asterisk); + _assign_at(@classification, 44, ElnaLexerClass.single); + _assign_at(@classification, 45, ElnaLexerClass.single); + _assign_at(@classification, 46, ElnaLexerClass.minus); + _assign_at(@classification, 47, ElnaLexerClass.dot); + _assign_at(@classification, 48, ElnaLexerClass.single); + _assign_at(@classification, 49, ElnaLexerClass.zero); + _assign_at(@classification, 50, ElnaLexerClass.digit); + _assign_at(@classification, 51, ElnaLexerClass.digit); + _assign_at(@classification, 52, ElnaLexerClass.digit); + _assign_at(@classification, 53, ElnaLexerClass.digit); + _assign_at(@classification, 54, ElnaLexerClass.digit); + _assign_at(@classification, 55, ElnaLexerClass.digit); + _assign_at(@classification, 56, ElnaLexerClass.digit); + _assign_at(@classification, 57, ElnaLexerClass.digit); + _assign_at(@classification, 58, ElnaLexerClass.digit); + _assign_at(@classification, 59, ElnaLexerClass.colon); + _assign_at(@classification, 60, ElnaLexerClass.single); + _assign_at(@classification, 61, ElnaLexerClass.less); + _assign_at(@classification, 62, ElnaLexerClass.equals); + _assign_at(@classification, 63, ElnaLexerClass.greater); + _assign_at(@classification, 64, ElnaLexerClass.other); + _assign_at(@classification, 65, ElnaLexerClass.single); + _assign_at(@classification, 66, ElnaLexerClass.alpha); + _assign_at(@classification, 67, ElnaLexerClass.alpha); + _assign_at(@classification, 68, ElnaLexerClass.alpha); + _assign_at(@classification, 69, ElnaLexerClass.alpha); + _assign_at(@classification, 70, ElnaLexerClass.alpha); + _assign_at(@classification, 71, ElnaLexerClass.alpha); + _assign_at(@classification, 72, ElnaLexerClass.alpha); + _assign_at(@classification, 73, ElnaLexerClass.alpha); + _assign_at(@classification, 74, ElnaLexerClass.alpha); + _assign_at(@classification, 75, ElnaLexerClass.alpha); + _assign_at(@classification, 76, ElnaLexerClass.alpha); + _assign_at(@classification, 77, ElnaLexerClass.alpha); + _assign_at(@classification, 78, ElnaLexerClass.alpha); + _assign_at(@classification, 79, ElnaLexerClass.alpha); + _assign_at(@classification, 80, ElnaLexerClass.alpha); + _assign_at(@classification, 81, ElnaLexerClass.alpha); + _assign_at(@classification, 82, ElnaLexerClass.alpha); + _assign_at(@classification, 83, ElnaLexerClass.alpha); + _assign_at(@classification, 84, ElnaLexerClass.alpha); + _assign_at(@classification, 85, ElnaLexerClass.alpha); + _assign_at(@classification, 86, ElnaLexerClass.alpha); + _assign_at(@classification, 87, ElnaLexerClass.alpha); + _assign_at(@classification, 88, ElnaLexerClass.alpha); + _assign_at(@classification, 89, ElnaLexerClass.alpha); + _assign_at(@classification, 90, ElnaLexerClass.alpha); + _assign_at(@classification, 91, ElnaLexerClass.alpha); + _assign_at(@classification, 92, ElnaLexerClass.single); + _assign_at(@classification, 93, ElnaLexerClass.backslash); + _assign_at(@classification, 94, ElnaLexerClass.single); + _assign_at(@classification, 95, ElnaLexerClass.single); + _assign_at(@classification, 96, ElnaLexerClass.alpha); + _assign_at(@classification, 97, ElnaLexerClass.other); + _assign_at(@classification, 98, ElnaLexerClass.hex); + _assign_at(@classification, 99, ElnaLexerClass.hex); + _assign_at(@classification, 100, ElnaLexerClass.hex); + _assign_at(@classification, 101, ElnaLexerClass.hex); + _assign_at(@classification, 102, ElnaLexerClass.hex); + _assign_at(@classification, 103, ElnaLexerClass.hex); + _assign_at(@classification, 104, ElnaLexerClass.alpha); + _assign_at(@classification, 105, ElnaLexerClass.alpha); + _assign_at(@classification, 106, ElnaLexerClass.alpha); + _assign_at(@classification, 107, ElnaLexerClass.alpha); + _assign_at(@classification, 108, ElnaLexerClass.alpha); + _assign_at(@classification, 109, ElnaLexerClass.alpha); + _assign_at(@classification, 110, ElnaLexerClass.alpha); + _assign_at(@classification, 111, ElnaLexerClass.alpha); + _assign_at(@classification, 112, ElnaLexerClass.alpha); + _assign_at(@classification, 113, ElnaLexerClass.alpha); + _assign_at(@classification, 114, ElnaLexerClass.alpha); + _assign_at(@classification, 115, ElnaLexerClass.alpha); + _assign_at(@classification, 116, ElnaLexerClass.alpha); + _assign_at(@classification, 117, ElnaLexerClass.alpha); + _assign_at(@classification, 118, ElnaLexerClass.alpha); + _assign_at(@classification, 119, ElnaLexerClass.alpha); + _assign_at(@classification, 120, ElnaLexerClass.alpha); + _assign_at(@classification, 121, ElnaLexerClass.x); + _assign_at(@classification, 122, ElnaLexerClass.alpha); + _assign_at(@classification, 123, ElnaLexerClass.alpha); + _assign_at(@classification, 124, ElnaLexerClass.other); + _assign_at(@classification, 125, ElnaLexerClass.single); + _assign_at(@classification, 126, ElnaLexerClass.other); + _assign_at(@classification, 127, ElnaLexerClass.single); + _assign_at(@classification, 128, ElnaLexerClass.invalid); code := 129; (* Set the remaining 129 - 256 bytes to transitionClassOther. *) .create_classification_loop; - _assign_at(@classification, code, LexerClass.other); + _assign_at(@classification, code, ElnaLexerClass.other); code := code + 1; if code < 257 then @@ -4415,7 +4782,7 @@ begin end end; -proc _lexer_get_transition(current_state: Word, character_class: Word); +proc _elna_lexer_get_transition(current_state: Word, character_class: Word); var transition_table: Word; row_position: Word; @@ -4430,7 +4797,7 @@ begin column_position := character_class - 1; column_position := column_position * 8; - target := _lexer_get_transition_table(); + target := _elna_lexer_get_transition_table(); target := target + row_position; return target + column_position @@ -4443,14 +4810,14 @@ end; * action - Action to assign. * next_state - Next state to assign. *) -proc _lexer_set_transition(current_state: Word, character_class: Word, action: Word, next_state: Word); +proc _elna_lexer_set_transition(current_state: Word, character_class: Word, action: Word, next_state: Word); var transition: Word; begin - transition := _lexer_get_transition(current_state, character_class); + transition := _elna_lexer_get_transition(current_state, character_class); - _lexer_transition_set_action(transition, action); - _lexer_transition_set_state(transition, next_state) + _elna_lexer_transition_set_action(transition, action); + _elna_lexer_transition_set_state(transition, next_state) end; (* Sets same action and state transition for all character classes in one transition row. *) @@ -4461,30 +4828,30 @@ end; * default_action - Default action (Callback). * next_state - Next state (Transition state enumeration). *) -proc _lexer_default_transition(current_state: Word, default_action: Word, next_state: Word); +proc _elna_lexer_default_transition(current_state: Word, default_action: Word, next_state: Word); begin - _lexer_set_transition(current_state, LexerClass.invalid, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.digit, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.alpha, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.space, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.colon, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.equals, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.left_paren, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.right_paren, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.asterisk, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.backslash, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.single, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.hex, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.zero, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.x, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.eof, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.dot, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.minus, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.single_quote, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.double_quote, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.greater, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.less, default_action, next_state); - _lexer_set_transition(current_state, LexerClass.other, default_action, next_state) + _elna_lexer_set_transition(current_state, ElnaLexerClass.invalid, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.digit, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.alpha, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.space, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.colon, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.equals, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.left_paren, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.right_paren, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.asterisk, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.backslash, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.single, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.hex, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.zero, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.x, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.eof, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.dot, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.minus, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.single_quote, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.double_quote, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.greater, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.less, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.other, default_action, next_state) end; (** @@ -4495,116 +4862,116 @@ end; * the amount of classes. So given the current state and a classified character * the table can be used to look up the next state. *) -proc _lexer_transitions(); +proc _elna_lexer_transitions(); begin (* Start state. *) - _lexer_set_transition(LexerState.start, LexerClass.invalid, LexerAction.none, LexerState.finish); - _lexer_set_transition(LexerState.start, LexerClass.digit, LexerAction.accumulate, LexerState.decimal); - _lexer_set_transition(LexerState.start, LexerClass.alpha, LexerAction.accumulate, LexerState.identifier); - _lexer_set_transition(LexerState.start, LexerClass.space, LexerAction.skip, LexerState.start); - _lexer_set_transition(LexerState.start, LexerClass.colon, LexerAction.accumulate, LexerState.colon); - _lexer_set_transition(LexerState.start, LexerClass.equals, LexerAction.single, LexerState.finish); - _lexer_set_transition(LexerState.start, LexerClass.left_paren, LexerAction.accumulate, LexerState.left_paren); - _lexer_set_transition(LexerState.start, LexerClass.right_paren, LexerAction.single, LexerState.finish); - _lexer_set_transition(LexerState.start, LexerClass.asterisk, LexerAction.single, LexerState.finish); - _lexer_set_transition(LexerState.start, LexerClass.backslash, LexerAction.none, LexerState.finish); - _lexer_set_transition(LexerState.start, LexerClass.single, LexerAction.single, LexerState.finish); - _lexer_set_transition(LexerState.start, LexerClass.hex, LexerAction.accumulate, LexerState.identifier); - _lexer_set_transition(LexerState.start, LexerClass.zero, LexerAction.accumulate, LexerState.leading_zero); - _lexer_set_transition(LexerState.start, LexerClass.x, LexerAction.accumulate, LexerState.identifier); - _lexer_set_transition(LexerState.start, LexerClass.eof, LexerAction.eof, LexerState.finish); - _lexer_set_transition(LexerState.start, LexerClass.dot, LexerAction.single, LexerState.finish); - _lexer_set_transition(LexerState.start, LexerClass.minus, LexerAction.accumulate, LexerState.minus); - _lexer_set_transition(LexerState.start, LexerClass.single_quote, LexerAction.accumulate, LexerState.character); - _lexer_set_transition(LexerState.start, LexerClass.double_quote, LexerAction.accumulate, LexerState.string); - _lexer_set_transition(LexerState.start, LexerClass.greater, LexerAction.accumulate, LexerState.greater); - _lexer_set_transition(LexerState.start, LexerClass.less, LexerAction.accumulate, LexerState.less); - _lexer_set_transition(LexerState.start, LexerClass.other, LexerAction.none, LexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.digit, ElnaLexerAction.accumulate, ElnaLexerState.decimal); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.alpha, ElnaLexerAction.accumulate, ElnaLexerState.identifier); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.space, ElnaLexerAction.skip, ElnaLexerState.start); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.colon, ElnaLexerAction.accumulate, ElnaLexerState.colon); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.equals, ElnaLexerAction.single, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.left_paren, ElnaLexerAction.accumulate, ElnaLexerState.left_paren); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.right_paren, ElnaLexerAction.single, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.asterisk, ElnaLexerAction.single, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.backslash, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.single, ElnaLexerAction.single, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.hex, ElnaLexerAction.accumulate, ElnaLexerState.identifier); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.zero, ElnaLexerAction.accumulate, ElnaLexerState.leading_zero); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.x, ElnaLexerAction.accumulate, ElnaLexerState.identifier); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.eof, ElnaLexerAction.eof, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.dot, ElnaLexerAction.single, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.minus, ElnaLexerAction.accumulate, ElnaLexerState.minus); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.single_quote, ElnaLexerAction.accumulate, ElnaLexerState.character); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.double_quote, ElnaLexerAction.accumulate, ElnaLexerState.string); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.greater, ElnaLexerAction.accumulate, ElnaLexerState.greater); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.less, ElnaLexerAction.accumulate, ElnaLexerState.less); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.other, ElnaLexerAction.none, ElnaLexerState.finish); (* Colon state. *) - _lexer_default_transition(LexerState.colon, LexerAction.finalize, LexerState.finish); - _lexer_set_transition(LexerState.colon, LexerClass.equals, LexerAction.composite, LexerState.finish); + _elna_lexer_default_transition(ElnaLexerState.colon, ElnaLexerAction.finalize, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.colon, ElnaLexerClass.equals, ElnaLexerAction.composite, ElnaLexerState.finish); (* Identifier state. *) - _lexer_default_transition(LexerState.identifier, LexerAction.key_id, LexerState.finish); - _lexer_set_transition(LexerState.identifier, LexerClass.digit, LexerAction.accumulate, LexerState.identifier); - _lexer_set_transition(LexerState.identifier, LexerClass.alpha, LexerAction.accumulate, LexerState.identifier); - _lexer_set_transition(LexerState.identifier, LexerClass.hex, LexerAction.accumulate, LexerState.identifier); - _lexer_set_transition(LexerState.identifier, LexerClass.zero, LexerAction.accumulate, LexerState.identifier); - _lexer_set_transition(LexerState.identifier, LexerClass.x, LexerAction.accumulate, LexerState.identifier); + _elna_lexer_default_transition(ElnaLexerState.identifier, ElnaLexerAction.key_id, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.identifier, ElnaLexerClass.digit, ElnaLexerAction.accumulate, ElnaLexerState.identifier); + _elna_lexer_set_transition(ElnaLexerState.identifier, ElnaLexerClass.alpha, ElnaLexerAction.accumulate, ElnaLexerState.identifier); + _elna_lexer_set_transition(ElnaLexerState.identifier, ElnaLexerClass.hex, ElnaLexerAction.accumulate, ElnaLexerState.identifier); + _elna_lexer_set_transition(ElnaLexerState.identifier, ElnaLexerClass.zero, ElnaLexerAction.accumulate, ElnaLexerState.identifier); + _elna_lexer_set_transition(ElnaLexerState.identifier, ElnaLexerClass.x, ElnaLexerAction.accumulate, ElnaLexerState.identifier); (* Decimal state. *) - _lexer_default_transition(LexerState.decimal, LexerAction.integer, LexerState.finish); - _lexer_set_transition(LexerState.decimal, LexerClass.digit, LexerAction.accumulate, LexerState.decimal); - _lexer_set_transition(LexerState.decimal, LexerClass.alpha, LexerAction.none, LexerState.finish); - _lexer_set_transition(LexerState.decimal, LexerClass.hex, LexerAction.none, LexerState.finish); - _lexer_set_transition(LexerState.decimal, LexerClass.zero, LexerAction.accumulate, LexerState.decimal); - _lexer_set_transition(LexerState.decimal, LexerClass.x, LexerAction.none, LexerState.finish); + _elna_lexer_default_transition(ElnaLexerState.decimal, ElnaLexerAction.integer, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.decimal, ElnaLexerClass.digit, ElnaLexerAction.accumulate, ElnaLexerState.decimal); + _elna_lexer_set_transition(ElnaLexerState.decimal, ElnaLexerClass.alpha, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.decimal, ElnaLexerClass.hex, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.decimal, ElnaLexerClass.zero, ElnaLexerAction.accumulate, ElnaLexerState.decimal); + _elna_lexer_set_transition(ElnaLexerState.decimal, ElnaLexerClass.x, ElnaLexerAction.none, ElnaLexerState.finish); (* Leading zero. *) - _lexer_default_transition(LexerState.leading_zero, LexerAction.integer, LexerState.finish); - _lexer_set_transition(LexerState.leading_zero, LexerClass.digit, LexerAction.none, LexerState.finish); - _lexer_set_transition(LexerState.leading_zero, LexerClass.alpha, LexerAction.none, LexerState.finish); - _lexer_set_transition(LexerState.leading_zero, LexerClass.hex, LexerAction.none, LexerState.finish); - _lexer_set_transition(LexerState.leading_zero, LexerClass.zero, LexerAction.none, LexerState.finish); - _lexer_set_transition(LexerState.leading_zero, LexerClass.x, LexerAction.none, LexerState.dot); + _elna_lexer_default_transition(ElnaLexerState.leading_zero, ElnaLexerAction.integer, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.leading_zero, ElnaLexerClass.digit, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.leading_zero, ElnaLexerClass.alpha, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.leading_zero, ElnaLexerClass.hex, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.leading_zero, ElnaLexerClass.zero, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.leading_zero, ElnaLexerClass.x, ElnaLexerAction.none, ElnaLexerState.dot); (* Greater state. *) - _lexer_default_transition(LexerState.greater, LexerAction.finalize, LexerState.finish); - _lexer_set_transition(LexerState.greater, LexerClass.equals, LexerAction.composite, LexerState.finish); + _elna_lexer_default_transition(ElnaLexerState.greater, ElnaLexerAction.finalize, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.greater, ElnaLexerClass.equals, ElnaLexerAction.composite, ElnaLexerState.finish); (* Minus state. *) - _lexer_default_transition(LexerState.minus, LexerAction.finalize, LexerState.finish); - _lexer_set_transition(LexerState.minus, LexerClass.greater, LexerAction.composite, LexerState.finish); + _elna_lexer_default_transition(ElnaLexerState.minus, ElnaLexerAction.finalize, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.minus, ElnaLexerClass.greater, ElnaLexerAction.composite, ElnaLexerState.finish); (* Left paren state. *) - _lexer_default_transition(LexerState.left_paren, LexerAction.finalize, LexerState.finish); - _lexer_set_transition(LexerState.left_paren, LexerClass.asterisk, LexerAction.accumulate, LexerState.comment); + _elna_lexer_default_transition(ElnaLexerState.left_paren, ElnaLexerAction.finalize, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.left_paren, ElnaLexerClass.asterisk, ElnaLexerAction.accumulate, ElnaLexerState.comment); (* Less state. *) - _lexer_default_transition(LexerState.less, LexerAction.finalize, LexerState.finish); - _lexer_set_transition(LexerState.less, LexerClass.equals, LexerAction.composite, LexerState.finish); - _lexer_set_transition(LexerState.less, LexerClass.greater, LexerAction.composite, LexerState.finish); + _elna_lexer_default_transition(ElnaLexerState.less, ElnaLexerAction.finalize, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.less, ElnaLexerClass.equals, ElnaLexerAction.composite, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.less, ElnaLexerClass.greater, ElnaLexerAction.composite, ElnaLexerState.finish); (* Hexadecimal after 0x. *) - _lexer_default_transition(LexerState.dot, LexerAction.finalize, LexerState.finish); - _lexer_set_transition(LexerState.dot, LexerClass.dot, LexerAction.composite, LexerState.finish); + _elna_lexer_default_transition(ElnaLexerState.dot, ElnaLexerAction.finalize, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.dot, ElnaLexerClass.dot, ElnaLexerAction.composite, ElnaLexerState.finish); (* Comment. *) - _lexer_default_transition(LexerState.comment, LexerAction.accumulate, LexerState.comment); - _lexer_set_transition(LexerState.comment, LexerClass.asterisk, LexerAction.accumulate, LexerState.closing_comment); - _lexer_set_transition(LexerState.comment, LexerClass.eof, LexerAction.none, LexerState.finish); + _elna_lexer_default_transition(ElnaLexerState.comment, ElnaLexerAction.accumulate, ElnaLexerState.comment); + _elna_lexer_set_transition(ElnaLexerState.comment, ElnaLexerClass.asterisk, ElnaLexerAction.accumulate, ElnaLexerState.closing_comment); + _elna_lexer_set_transition(ElnaLexerState.comment, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish); (* Closing comment. *) - _lexer_default_transition(LexerState.closing_comment, LexerAction.accumulate, LexerState.comment); - _lexer_set_transition(LexerState.closing_comment, LexerClass.invalid, LexerAction.none, LexerState.finish); - _lexer_set_transition(LexerState.closing_comment, LexerClass.right_paren, LexerAction.delimited, LexerState.finish); - _lexer_set_transition(LexerState.closing_comment, LexerClass.asterisk, LexerAction.accumulate, LexerState.closing_comment); - _lexer_set_transition(LexerState.closing_comment, LexerClass.eof, LexerAction.none, LexerState.finish); + _elna_lexer_default_transition(ElnaLexerState.closing_comment, ElnaLexerAction.accumulate, ElnaLexerState.comment); + _elna_lexer_set_transition(ElnaLexerState.closing_comment, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.closing_comment, ElnaLexerClass.right_paren, ElnaLexerAction.delimited, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.closing_comment, ElnaLexerClass.asterisk, ElnaLexerAction.accumulate, ElnaLexerState.closing_comment); + _elna_lexer_set_transition(ElnaLexerState.closing_comment, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish); (* Character. *) - _lexer_default_transition(LexerState.character, LexerAction.accumulate, LexerState.character); - _lexer_set_transition(LexerState.character, LexerClass.invalid, LexerAction.none, LexerState.finish); - _lexer_set_transition(LexerState.character, LexerClass.eof, LexerAction.none, LexerState.finish); - _lexer_set_transition(LexerState.character, LexerClass.single_quote, LexerAction.delimited, LexerState.finish); - _lexer_set_transition(LexerState.character, LexerClass.backslash, LexerAction.accumulate, LexerState.character_escape); + _elna_lexer_default_transition(ElnaLexerState.character, ElnaLexerAction.accumulate, ElnaLexerState.character); + _elna_lexer_set_transition(ElnaLexerState.character, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.character, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.character, ElnaLexerClass.single_quote, ElnaLexerAction.delimited, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.character, ElnaLexerClass.backslash, ElnaLexerAction.accumulate, ElnaLexerState.character_escape); (* Escape sequence in a character. *) - _lexer_default_transition(LexerState.character_escape, LexerAction.accumulate, LexerState.character); - _lexer_set_transition(LexerState.character_escape, LexerClass.invalid, LexerAction.none, LexerState.finish); - _lexer_set_transition(LexerState.character_escape, LexerClass.eof, LexerAction.none, LexerState.finish); + _elna_lexer_default_transition(ElnaLexerState.character_escape, ElnaLexerAction.accumulate, ElnaLexerState.character); + _elna_lexer_set_transition(ElnaLexerState.character_escape, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.character_escape, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish); (* String. *) - _lexer_default_transition(LexerState.string, LexerAction.accumulate, LexerState.string); - _lexer_set_transition(LexerState.string, LexerClass.invalid, LexerAction.none, LexerState.finish); - _lexer_set_transition(LexerState.string, LexerClass.eof, LexerAction.none, LexerState.finish); - _lexer_set_transition(LexerState.string, LexerClass.double_quote, LexerAction.delimited, LexerState.finish); - _lexer_set_transition(LexerState.string, LexerClass.backslash, LexerAction.accumulate, LexerState.string_escape); + _elna_lexer_default_transition(ElnaLexerState.string, ElnaLexerAction.accumulate, ElnaLexerState.string); + _elna_lexer_set_transition(ElnaLexerState.string, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.string, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.string, ElnaLexerClass.double_quote, ElnaLexerAction.delimited, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.string, ElnaLexerClass.backslash, ElnaLexerAction.accumulate, ElnaLexerState.string_escape); (* Escape sequence in a string. *) - _lexer_default_transition(LexerState.string_escape, LexerAction.accumulate, LexerState.string); - _lexer_set_transition(LexerState.string_escape, LexerClass.invalid, LexerAction.none, LexerState.finish); - _lexer_set_transition(LexerState.string_escape, LexerClass.eof, LexerAction.none, LexerState.finish) + _elna_lexer_default_transition(ElnaLexerState.string_escape, ElnaLexerAction.accumulate, ElnaLexerState.string); + _elna_lexer_set_transition(ElnaLexerState.string_escape, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.string_escape, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish) end; (** @@ -4612,7 +4979,7 @@ end; * Each character entry is 1 word long and there are 256 characters. * 1024 = 256 * 4 *) -proc _lexer_get_transition_table(); +proc _elna_lexer_get_transition_table(); return @classification + 1024 end; @@ -4621,78 +4988,74 @@ end; * Each transition table entry is 8 bytes long. The table has 16 rows (transition states) * and 22 columns (character classes), so 2992 = 8 * 17 * 22. *) -proc _lexer_global_state(); +proc _elna_lexer_global_state(); var result: Word; begin - result := _lexer_get_transition_table(); + result := _elna_lexer_get_transition_table(); return result + 2992 end; (** * Gets pointer to the token start. *) -proc _lexer_global_get_start(); +proc _elna_lexer_global_get_start(); var target: Word; begin - target := _lexer_global_state(); - target := target + 4; + target := _elna_lexer_global_state() + 4; return target^ end; (** * Sets pointer to the token start. *) -proc _lexer_global_set_start(new_start: Word); +proc _elna_lexer_global_set_start(new_start: Word); var target: Word; begin - target := _lexer_global_state(); - target := target + 4; + target := _elna_lexer_global_state() + 4; target^ := new_start end; (** * Gets pointer to the token end. *) -proc _lexer_global_get_end(); +proc _elna_lexer_global_get_end(); var target: Word; begin - target := _lexer_global_state(); - target := target + 8; + target := _elna_lexer_global_state() + 8; return target^ end; (** * Sets pointer to the token end. *) -proc _lexer_global_set_end(new_start: Word); +proc _elna_lexer_global_set_end(new_start: Word); var target: Word; begin - target := _lexer_global_state(); - target := target + 8; + target := _elna_lexer_global_state() + 8; target^ := new_start end; -proc _lexer_transition_get_action(this: Word); +proc _elna_lexer_transition_get_action(this: Word); return this^ end; -proc _lexer_transition_set_action(this: Word, value: Word); +proc _elna_lexer_transition_set_action(this: Word, value: Word); begin this^ := value end; -proc _lexer_transition_get_state(this: Word); +proc _elna_lexer_transition_get_state(this: Word); begin this := this + 4; return this^ end; -proc _lexer_transition_set_state(this: Word, value: Word); +proc _elna_lexer_transition_set_state(this: Word, value: Word); begin this := this + 4; this^ := value @@ -4701,48 +5064,48 @@ end; (** * Resets the lexer state for reading the next token. *) -proc _lexer_reset(); +proc _elna_lexer_reset(); var state: Word; begin (* Transition start state is 1. *) - state := _lexer_global_state(); - state^ := LexerState.start; + state := _elna_lexer_global_state(); + state^ := ElnaLexerState.start; - state := _lexer_global_get_start(); - _lexer_global_set_end(state) + state := _elna_lexer_global_get_start(); + _elna_lexer_global_set_end(state) end; (** * One time lexer initialization. *) -proc _lexer_initialize(code_pointer: Word); +proc _elna_lexer_initialize(code_pointer: Word); begin - _lexer_classifications(); - _lexer_transitions(); + _elna_lexer_classifications(); + _elna_lexer_transitions(); - _lexer_global_set_start(code_pointer); - _lexer_global_set_end(code_pointer) + _elna_lexer_global_set_start(code_pointer); + _elna_lexer_global_set_end(code_pointer) end; -proc _lexer_next_transition(); +proc _elna_lexer_next_transition(); var current_character: Word; character_class: Word; current_state: Word; begin - current_character := _lexer_global_get_end(); + current_character := _elna_lexer_global_get_end(); current_character := _load_byte(current_character); character_class := _get_at(@classification, current_character + 1); - current_state := _lexer_global_state(); + current_state := _elna_lexer_global_state(); current_state := current_state^; - return _lexer_get_transition(current_state, character_class) + return _elna_lexer_get_transition(current_state, character_class) end; -proc _lexer_compare_keyword(lhs_pointer: Word, lhs_length: Word, rhs_pointer: Word, rhs_length: Word); +proc _string_compare(lhs_pointer: Word, lhs_length: Word, rhs_pointer: Word, rhs_length: Word); var result: Word; begin @@ -4755,49 +5118,51 @@ begin return result end; -proc _lexer_classify_keyword(position_start: Word, position_end: Word); +proc _elna_lexer_classify_keyword(position_start: Word, position_end: Word); var result: Word; token_length: Word; begin - result := LexerTokenKind.identifier; + result := ElnaLexerKind.identifier; token_length := position_end - position_start; - if _lexer_compare_keyword(position_start, token_length, "const", 5) then - result := LexerTokenKind._const - elsif _lexer_compare_keyword(position_start, token_length, "var", 3) then - result := LexerTokenKind._var - elsif _lexer_compare_keyword(position_start, token_length, "proc", 4) then - result := LexerTokenKind._proc - elsif _lexer_compare_keyword(position_start, token_length, "type", 4) then - result := LexerTokenKind._type - elsif _lexer_compare_keyword(position_start, token_length, "begin", 5) then - result := LexerTokenKind._begin - elsif _lexer_compare_keyword(position_start, token_length, "end", 3) then - result := LexerTokenKind._end - elsif _lexer_compare_keyword(position_start, token_length, "return", 6) then - result := LexerTokenKind._return - elsif _lexer_compare_keyword(position_start, token_length, "goto", 4) then - result := LexerTokenKind._goto - elsif _lexer_compare_keyword(position_start, token_length, "if", 2) then - result := LexerTokenKind._if - elsif _lexer_compare_keyword(position_start, token_length, "while", 5) then - result := LexerTokenKind._while - elsif _lexer_compare_keyword(position_start, token_length, "then", 4) then - result := LexerTokenKind._then - elsif _lexer_compare_keyword(position_start, token_length, "else", 4) then - result := LexerTokenKind._else - elsif _lexer_compare_keyword(position_start, token_length, "elsif", 5) then - result := LexerTokenKind._elsif - elsif _lexer_compare_keyword(position_start, token_length, "or", 2) then - result := LexerTokenKind._or - elsif _lexer_compare_keyword(position_start, token_length, "xor", 2) then - result := LexerTokenKind._xor + if _string_compare(position_start, token_length, "const", 5) then + result := ElnaLexerKind._const + elsif _string_compare(position_start, token_length, "var", 3) then + result := ElnaLexerKind._var + elsif _string_compare(position_start, token_length, "proc", 4) then + result := ElnaLexerKind._proc + elsif _string_compare(position_start, token_length, "type", 4) then + result := ElnaLexerKind._type + elsif _string_compare(position_start, token_length, "begin", 5) then + result := ElnaLexerKind._begin + elsif _string_compare(position_start, token_length, "end", 3) then + result := ElnaLexerKind._end + elsif _string_compare(position_start, token_length, "return", 6) then + result := ElnaLexerKind._return + elsif _string_compare(position_start, token_length, "goto", 4) then + result := ElnaLexerKind._goto + elsif _string_compare(position_start, token_length, "if", 2) then + result := ElnaLexerKind._if + elsif _string_compare(position_start, token_length, "while", 5) then + result := ElnaLexerKind._while + elsif _string_compare(position_start, token_length, "then", 4) then + result := ElnaLexerKind._then + elsif _string_compare(position_start, token_length, "else", 4) then + result := ElnaLexerKind._else + elsif _string_compare(position_start, token_length, "elsif", 5) then + result := ElnaLexerKind._elsif + elsif _string_compare(position_start, token_length, "record", 6) then + result := ElnaLexerKind._record + elsif _string_compare(position_start, token_length, "or", 2) then + result := ElnaLexerKind._or + elsif _string_compare(position_start, token_length, "xor", 2) then + result := ElnaLexerKind._xor end; return result end; -proc _lexer_classify_finalize(start_position: Word); +proc _elna_lexer_classify_finalize(start_position: Word); var character: Word; result: Word; @@ -4806,22 +5171,22 @@ begin character := _load_byte(start_position); if character = ':' then - result := LexerTokenKind.colon + result := ElnaLexerKind.colon elsif character = '.' then - result := LexerTokenKind.dot + result := ElnaLexerKind.dot elsif character = '(' then - result := LexerTokenKind.left_paren + result := ElnaLexerKind.left_paren elsif character = '-' then - result := LexerTokenKind.minus + result := ElnaLexerKind.minus elsif character = '<' then - result := LexerTokenKind.less_than + result := ElnaLexerKind.less_than elsif character = '>' then - result := LexerTokenKind.greater_than + result := ElnaLexerKind.greater_than end; return result end; -proc _lexer_classify_single(start_position: Word); +proc _elna_lexer_classify_single(start_position: Word); var character: Word; result: Word; @@ -4830,36 +5195,36 @@ begin character := _load_byte(start_position); if character = ';' then - result := LexerTokenKind.semicolon + result := ElnaLexerKind.semicolon elsif character = ',' then - result := LexerTokenKind.comma + result := ElnaLexerKind.comma elsif character = ')' then - result := LexerTokenKind.right_paren + result := ElnaLexerKind.right_paren elsif character = '@' then - result := LexerTokenKind.at + result := ElnaLexerKind.at elsif character = '~' then - result := LexerTokenKind.not + result := ElnaLexerKind.not elsif character = '&' then - result := LexerTokenKind.and + result := ElnaLexerKind.and elsif character = '+' then - result := LexerTokenKind.plus + result := ElnaLexerKind.plus elsif character = '*' then - result := LexerTokenKind.multiplication + result := ElnaLexerKind.multiplication elsif character = '=' then - result := LexerTokenKind.equals + result := ElnaLexerKind.equals elsif character = '%' then - result := LexerTokenKind.remainder + result := ElnaLexerKind.remainder elsif character = '/' then - result := LexerTokenKind.division + result := ElnaLexerKind.division elsif character = '.' then - result := LexerTokenKind.dot + result := ElnaLexerKind.dot elsif character = '^' then - result := LexerTokenKind.hat + result := ElnaLexerKind.hat end; return result end; -proc _lexer_classify_composite(start_position: Word, one_before_last: Word); +proc _elna_lexer_classify_composite(start_position: Word, one_before_last: Word); var first_character: Word; last_character: Word; @@ -4869,23 +5234,23 @@ begin last_character := _load_byte(one_before_last); if first_character = ':' then - result := LexerTokenKind.assignment + result := ElnaLexerKind.assignment elsif first_character = '<' then if last_character = '=' then - result := LexerTokenKind.less_equal + result := ElnaLexerKind.less_equal elsif last_character = '>' then - result := LexerTokenKind.not_equal + result := ElnaLexerKind.not_equal end elsif first_character = '>' then if last_character = '=' then - result := LexerTokenKind.greater_equal + result := ElnaLexerKind.greater_equal end end; return result end; -proc _lexer_classify_delimited(start_position: Word, end_position: Word); +proc _elna_lexer_classify_delimited(start_position: Word, end_position: Word); var token_length: Word; delimiter: Word; @@ -4895,112 +5260,111 @@ begin delimiter := _load_byte(start_position); if delimiter = '(' then - result := LexerTokenKind.comment + result := ElnaLexerKind.comment elsif delimiter = '\'' then - result := LexerTokenKind.character + result := ElnaLexerKind.character elsif delimiter = '"' then - result := LexerTokenKind.string + result := ElnaLexerKind.string end; return result end; -proc _lexer_classify_integer(start_position: Word, end_position: Word); -begin - return LexerTokenKind.integer +proc _elna_lexer_classify_integer(start_position: Word, end_position: Word); + return ElnaLexerKind.integer end; -proc _lexer_execute_action(action_to_perform: Word, kind: Word); +proc _elna_lexer_execute_action(action_to_perform: Word, kind: Word); var position_start: Word; position_end: Word; intermediate: Word; begin - position_start := _lexer_global_get_start(); - position_end := _lexer_global_get_end(); + position_start := _elna_lexer_global_get_start(); + position_end := _elna_lexer_global_get_end(); - if action_to_perform = LexerAction.none then - elsif action_to_perform = LexerAction.accumulate then - _lexer_global_set_end(position_end + 1) - elsif action_to_perform = LexerAction.skip then - _lexer_global_set_start(position_start + 1); - _lexer_global_set_end(position_end + 1) - elsif action_to_perform = LexerAction.single then - _lexer_global_set_end(position_end + 1); + if action_to_perform = ElnaLexerAction.none then + elsif action_to_perform = ElnaLexerAction.accumulate then + _elna_lexer_global_set_end(position_end + 1) + elsif action_to_perform = ElnaLexerAction.skip then + _elna_lexer_global_set_start(position_start + 1); + _elna_lexer_global_set_end(position_end + 1) + elsif action_to_perform = ElnaLexerAction.single then + _elna_lexer_global_set_end(position_end + 1); - intermediate := _lexer_classify_single(position_start); + intermediate := _elna_lexer_classify_single(position_start); kind^ := intermediate - elsif action_to_perform = LexerAction.eof then - intermediate := LexerTokenKind.eof; + elsif action_to_perform = ElnaLexerAction.eof then + intermediate := ElnaLexerKind.eof; kind^ := intermediate - elsif action_to_perform = LexerAction.finalize then - intermediate := _lexer_classify_finalize(position_start); + elsif action_to_perform = ElnaLexerAction.finalize then + intermediate := _elna_lexer_classify_finalize(position_start); kind^ := intermediate - elsif action_to_perform = LexerAction.composite then - _lexer_global_set_end(position_end + 1); + elsif action_to_perform = ElnaLexerAction.composite then + _elna_lexer_global_set_end(position_end + 1); - intermediate := _lexer_classify_composite(position_start, position_end); + intermediate := _elna_lexer_classify_composite(position_start, position_end); kind^ := intermediate - elsif action_to_perform = LexerAction.key_id then - intermediate := _lexer_classify_keyword(position_start, position_end); + elsif action_to_perform = ElnaLexerAction.key_id then + intermediate := _elna_lexer_classify_keyword(position_start, position_end); kind^ := intermediate - elsif action_to_perform = LexerAction.integer then - intermediate := _lexer_classify_integer(position_start, position_end); + elsif action_to_perform = ElnaLexerAction.integer then + intermediate := _elna_lexer_classify_integer(position_start, position_end); kind^ := intermediate - elsif action_to_perform = LexerAction.delimited then - _lexer_global_set_end(position_end + 1); + elsif action_to_perform = ElnaLexerAction.delimited then + _elna_lexer_global_set_end(position_end + 1); - intermediate := _lexer_classify_delimited(position_start, position_end + 1); + intermediate := _elna_lexer_classify_delimited(position_start, position_end + 1); kind^ := intermediate - end; + end end; -proc _lexer_execute_transition(kind: Word); +proc _elna_lexer_execute_transition(kind: Word); var next_transition: Word; next_state: Word; global_state: Word; action_to_perform: Word; begin - next_transition := _lexer_next_transition(); - next_state := _lexer_transition_get_state(next_transition); - action_to_perform := _lexer_transition_get_action(next_transition); + next_transition := _elna_lexer_next_transition(); + next_state := _elna_lexer_transition_get_state(next_transition); + action_to_perform := _elna_lexer_transition_get_action(next_transition); - global_state := _lexer_global_state(); + global_state := _elna_lexer_global_state(); global_state^ := next_state; - _lexer_execute_action(action_to_perform, kind); + _elna_lexer_execute_action(action_to_perform, kind); return next_state end; -proc _lexer_advance_token(kind: Word); +proc _elna_lexer_advance_token(kind: Word); var result_state: Word; begin - result_state := _lexer_execute_transition(kind); - if result_state <> LexerState.finish then - _lexer_advance_token(kind) + result_state := _elna_lexer_execute_transition(kind); + if result_state <> ElnaLexerState.finish then + _elna_lexer_advance_token(kind) end end; (** * Reads the next token and writes its type into the address in the kind parameter. *) -proc _lexer_read_token(kind: Word); +proc _elna_lexer_read_token(kind: Word); begin - _lexer_reset(); - _lexer_advance_token(kind) + _elna_lexer_reset(); + _elna_lexer_advance_token(kind) end; (** * Advances the token stream past the last read token. *) -proc _lexer_skip_token(); +proc _elna_lexer_skip_token(); var old_end: Word; begin - old_end := _lexer_global_get_end(); - _lexer_global_set_start(old_end) + old_end := _elna_lexer_global_get_end(); + _elna_lexer_global_set_start(old_end) end; proc _initialize_global_state(); @@ -5020,7 +5384,7 @@ var offset: Word; begin _initialize_global_state(); - _lexer_initialize(source_code); + _elna_lexer_initialize(source_code); _symbol_table_build(); (* Read the source from the standard input. *) diff --git a/boot/stage16.elna b/boot/stage16.elna new file mode 100644 index 0000000..cd56cc2 --- /dev/null +++ b/boot/stage16.elna @@ -0,0 +1,4772 @@ +(* + * This Source Code Form is subject to the terms of the Mozilla Public License, + * v. 2.0. If a copy of the MPL was not distributed with this file, You can + * obtain one at https://mozilla.org/MPL/2.0/. + *) + +(* Stage 15 compiler. *) + +type + _elna_tac_declaration = record + next: Word; + name: Word; + length: Word; + body: Word + end; + _node = record + kind: Word + end; + _integer_literal_node = record + kind: Word; + value: Word; + length: Word + end; + _character_literal_node = record + kind: Word; + value: Word; + length: Word + end; + _variable_expression = record + kind: Word; + name: Word; + length: Word + end; + _string_literal_node = record + kind: Word; + value: Word; + length: Word + end; + _dereference_expression = record + kind: Word; + pointer: Word + end; + _binary_expression = record + kind: Word; + lhs: Word; + rhs: Word; + operator: Word + end; + _unary_expression = record + kind: Word; + operand: Word; + operator: Word + end; + _if_statement = record + kind: Word; + next: Word; + conditionals: Word; + _else: Word + end; + + (** + * All statements are chained into a list. Next contains a pointer to the next + * statement in the statement list. + *) + _statement = record + kind: Word; + next: Word + end; + _goto_statement = record + kind: Word; + next: Word; + label: Word; + length: Word + end; + _label_declaration = record + kind: Word; + next: Word; + label: Word; + length: Word + end; + _field_access_expression = record + kind: Word; + aggregate: Word; + field: Word; + length: Word + end; + _elna_tac_module = record + data: Word; + code: Word + end; + _module_declaration = record + kind: Word; + types: Word; + globals: Word; + procedures: Word + end; + _assign_statement = record + kind: Word; + next: Word; + assignee: Word; + assignment: Word + end; + _return_statement = record + kind: Word; + next: Word; + returned: Word + end; + _type = record + kind: Word; + size: Word + end; + _enumeration_type = record + kind: Word; + size: Word; + members: Word; + length: Word + end; + _enumeration_type_expression = record + kind: Word; + members: Word; + length: Word + end; + _record_type = record + kind: Word; + size: Word; + members: Word; + length: Word + end; + _record_type_expression = record + kind: Word; + members: Word; + length: Word + end; + _named_type_expression = record + kind: Word; + name: Word; + length: Word + end; + + (** + * Conditional statements is a list of pairs: condition and statements. + * Used for example to represent if and elsif blocks with beloning statements. + *) + _conditional_statements = record + condition: Word; + statements: Word; + next: Word + end; + + _declaration = record + kind: Word; + next: Word; + name: Word; + length: Word + end; + _procedure_declaration = record + kind: Word; + next: Word; + name: Word; + length: Word; + body: Word; + temporaries: Word; + parameters: Word + end; + _type_declaration = record + kind: Word; + next: Word; + name: Word; + length: Word; + _type: Word + end; + _variable_declaration = record + kind: Word; + next: Word; + name: Word; + length: Word; + _type: Word + end; + + ElnaLexerAction = (none, accumulate, skip, single, eof, finalize, composite, key_id, integer, delimited); + + (** + * Classification table assigns each possible character to a group (class). All + * characters of the same group a handled equivalently. + * + * Transition = record + * action: TransitionAction; + * next_state: TransitionState + * end; + *) + ElnaLexerClass = ( + invalid, + digit, + alpha, + space, + colon, + equals, + left_paren, + right_paren, + asterisk, + backslash, + single, + hex, + zero, + x, + eof, + dot, + minus, + single_quote, + double_quote, + greater, + less, + other + ); + ElnaLexerState = ( + start, + colon, + identifier, + decimal, + leading_zero, + greater, + minus, + left_paren, + less, + dot, + comment, + closing_comment, + character, + character_escape, + string, + string_escape, + finish + ); + ElnaLexerKind = ( + identifier, + _const, + _var, + _proc, + _type, + _begin, + _end, + _if, + _then, + _else, + _elsif, + _while, + _do, + _extern, + _record, + _true, + _false, + null, + and, + _or, + _xor, + pipe, + not, + _return, + _module, + _program, + _import, + _cast, + _defer, + _case, + _of, + trait, + left_paren, + right_paren, + left_square, + right_square, + shift_left, + shift_right, + greater_equal, + less_equal, + greater_than, + less_than, + not_equal, + equals, + semicolon, + dot, + comma, + plus, + arrow, + minus, + multiplication, + division, + remainder, + assignment, + colon, + hat, + at, + comment, + string, + character, + integer, + word, + _goto, + eof + ); + NodeKind = ( + integer_literal, + string_literal, + character_literal, + variable_expression, + field_access_expression, + dereference_expression, + unary_expression, + binary_expression, + call, + goto_statement, + label_declaration, + return_statement, + assign_statement, + if_statement, + procedure_declaration, + variable_declaration, + enumeration_type_expression, + named_type_expression, + type_declaration, + module_declaration, + record_type_expression + ); + InfoKind = (type_info, parameter_info, temporary_info, procedure_info); + TypeKind = (primitive, enumeration, _record); + ElnaTacOperator = ( + load_immediate, + load_address, + add, + add_immediate, + load_word, + store_word, + jal, + move, + sub, + div, + rem, + mul, + _xor, + _or, + and, + seqz, + snez, + slt, + xor_immediate, + neg, + not, + jump, + beqz, + label, + start, + ret + ); + ElnaTacOperand = (register, immediate, symbol, offset); + ElnaTacRegister = ( + zero, + ra, + sp, + gp, + tp, + t0, + t1, + t2, + s0, + s1, + a0, + a1, + a2, + a3, + a4, + a5, + a6, + a7, + s2, + s3, + s4, + s5, + s6, + s7, + s8, + s9, + s10, + s11, + t3, + t4, + t5, + t6 + ); + +var + symbol_table_global: Array; + compiler_strings: Array; + classification: Array; + + source_code: Word; + compiler_strings_position: Word; + compiler_strings_length: Word; + label_counter: Word; + symbol_table_store: Word; + + (* Points to a segment of free memory. *) + memory_free_pointer: Word; + +(** + * Calculates and returns the string token length between quotes, including the + * escaping slash characters. + * + * Parameters: + * string - String token pointer. + * + * Returns the length in a0. + *) +proc _string_length(string: Word); +var + counter: Word; + current_byte: Word; +begin + (* Reset the counter. *) + counter := 0; + + .string_length_loop; + string := string + 1; + + current_byte := _load_byte(string); + if current_byte <> '"' then + counter := counter + 1; + goto string_length_loop + end; + + return counter +end; + +(** + * Adds a string to the global, read-only string storage. + * + * Parameters: + * string - String token. + * + * Returns the offset from the beginning of the storage to the new string in a0. + *) +proc _add_string(string: Word); +var + contents: Word; + result: Word; + current_byte: Word; +begin + contents := string + 1; + result := compiler_strings_length; + + .add_string_loop; + current_byte := _load_byte(contents); + if current_byte <> '"' then + _store_byte(current_byte, compiler_strings_position); + compiler_strings_position := compiler_strings_position + 1; + contents := contents + 1; + + if current_byte <> '\\' then + compiler_strings_length := compiler_strings_length + 1 + end; + goto add_string_loop + end; + + return result +end; + +(** + * Reads standard input into a buffer. + * + * Parameters: + * buffer - Buffer pointer. + * size - Buffer size. + * + * Returns the amount of bytes written in a0. + *) +proc _read_file(buffer: Word, size: Word); + return _syscall(0, buffer, size, 0, 0, 0, 63) +end; + +(** + * MAP_ANONYMOUS is 32. + * PROT_READ | PORT_WRITE is (1 | 2). + * MAP_ANONYMOUS | MAP_PRIVATE is (32 | 2) + *) +proc _mmap(length: Word); + return _syscall(0, length, 1 or 2, 32 or 2, -1, 0, 222) +end; + +(** + * Writes to the standard output. + * + * Parameters: + * buffer - Buffer. + * size - Buffer length. + *) +proc _write_s(buffer: Word, size: Word); +begin + _syscall(1, buffer, size, 0, 0, 0, 64) +end; + +(** + * Writes a number to a string buffer. + * + * Parameters: + * number - Whole number. + * output_buffer - Buffer pointer. + * + * Sets a0 to the length of the written number. + *) +proc _print_i(number: Word, output_buffer: Word); +var + local_buffer: Word; + is_negative: Word; + current_character: Word; + result: Word; +begin + local_buffer := @result + 11; + + if number >= 0 then + is_negative := 0 + else + number = -number; + is_negative := 1 + end; + + .print_i_digit10; + current_character := number % 10; + _store_byte(current_character + '0', local_buffer); + + number := number / 10; + local_buffer := local_buffer - 1; + + if number <> 0 then + goto print_i_digit10 + end; + if is_negative = 1 then + _store_byte('-', local_buffer); + local_buffer := local_buffer - 1 + end; + result := @result + 11; + result := result - local_buffer; + _memcpy(output_buffer, local_buffer + 1, result); + + return result +end; + +(** + * Writes a number to the standard output. + * + * Parameters: + * number - Whole number. + *) +proc _write_i(number: Word); +var + local_buffer: Word; + length: Word; +begin + length := _print_i(number, @local_buffer); + _write_s(@local_buffer, length) +end; + +(** + * Writes a character from a0 into the standard output. + * + * Parameters: + * character - Character to write. + *) +proc _write_c(character: Word); +begin + _write_s(@character, 1) +end; + +(** + * Write null terminated string. + * + * Parameters: + * string - String. + *) +proc _write_z(string: Word); +var + next_byte: Word; +begin + (* Check for 0 character. *) + next_byte := _load_byte(string); + + if next_byte <> 0 then + (* Print a character. *) + _write_c(next_byte); + + (* Advance the input string by one byte. *) + _write_z(string + 1) + end +end; + +(** + * Detects if a0 is an uppercase character. Sets a0 to 1 if so, otherwise to 0. + *) +proc _is_upper(character: Word); +var + lhs: Word; + rhs: Word; +begin + lhs := character >= 'A'; + rhs := character <= 'Z'; + + return lhs & rhs +end; + +(** + * Detects if a0 is an lowercase character. Sets a0 to 1 if so, otherwise to 0. + *) +proc _is_lower(character: Word); +var + lhs: Word; + rhs: Word; +begin + lhs := character >= 'a'; + rhs := character <= 'z'; + + return lhs & rhs +end; + +(** + * Detects if the passed character is a 7-bit alpha character or an underscore. + * + * Paramters: + * character - Tested character. + * + * Sets a0 to 1 if the character is an alpha character or underscore, sets it to 0 otherwise. + *) +proc _is_alpha(character: Word); +var + is_upper_result: Word; + is_lower_result: Word; + is_alpha_result: Word; + is_underscore: Word; +begin + is_upper_result := _is_upper(character); + is_lower_result := _is_lower(character); + is_underscore := character = '_'; + + is_alpha_result := is_lower_result or is_upper_result; + return is_alpha_result or is_underscore +end; + +(** + * Detects whether the passed character is a digit (a value between 0 and 9). + * + * Parameters: + * character - Exemined value. + * + * Sets a0 to 1 if it is a digit, to 0 otherwise. + *) +proc _is_digit(character: Word); +var + lhs: Word; + rhs: Word; +begin + lhs := character >= '0'; + rhs := character <= '9'; + + return lhs & rhs +end; + +proc _is_alnum(character: Word); +var + lhs: Word; + rhs: Word; +begin + lhs := _is_alpha(character); + rhs := _is_digit(character); + + return lhs or rhs +end; + +(** + * Parameters: + * lhs - First pointer. + * rhs - Second pointer. + * count - The length to compare. + * + * Returns 0 if memory regions are equal. + *) +proc _memcmp(lhs: Word, rhs: Word, count: Word); +var + lhs_byte: Word; + rhs_byte: Word; + result: Word; +begin + result := 0; + + .memcmp_loop; + if count <> 0 then + lhs_byte := _load_byte(lhs); + rhs_byte := _load_byte(rhs); + result := lhs_byte - rhs_byte; + + lhs := lhs + 1; + rhs := rhs + 1; + count := count - 1; + + if result = 0 then + goto memcmp_loop + end + end; + + return result +end; + +(** + * Copies memory. + * + * Parameters: + * destination - Destination. + * source - Source. + * count - Size. + * + * Returns the destination. + *) +proc _memcpy(destination: Word, source: Word, count: Word); +var + current_byte: Word; +begin + .memcpy_loop; + if count <> 0 then + current_byte := _load_byte(source); + _store_byte(current_byte, destination); + + destination := destination + 1; + source := source + 1; + count := count - 1; + goto memcpy_loop + end; + + return destination +end; + +proc _elna_tac_instruction_size(); + return 44 +end; + +proc _elna_tac_instruction_get_kind(this: Word); + return this^ +end; + +proc _elna_tac_instruction_set_kind(this: Word, value: Word); +begin + this^ := value +end; + +proc _elna_tac_instruction_get_next(this: Word); +begin + this := this + 4; + return this^ +end; + +proc _elna_tac_instruction_set_next(this: Word, value: Word); +begin + .elna_tac_instruction_set_next_loop; + this := this + 4; + if value <> 0 then + if this^ <> 0 then + this := this^; + goto elna_tac_instruction_set_next_loop + end + end; + this^ := value +end; + +proc _elna_tac_instruction_get_operand_type(this: Word, n: Word); +begin + n := n - 1; + n := n * 12; + this := this + 8; + this := this + n; + + return this^ +end; + +proc _elna_tac_instruction_get_operand_value(this: Word, n: Word); +begin + n := n - 1; + n := n * 12; + this := this + 8; + this := this + n; + + this := this + 4; + return this^ +end; + +proc _elna_tac_instruction_get_operand_length(this: Word, n: Word); +begin + n := n - 1; + n := n * 12; + this := this + 8; + this := this + n; + + this := this + 8; + return this^ +end; + +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; + this := this + 8; + this := this + n; + + this^ := operand_type; + this := this + 4; + this^ := operand_value; + this := this + 4; + this^ := operand_length +end; + +proc _elna_tac_instruction_create(kind: Word); +var + result: Word; + instruction_size: Word; +begin + instruction_size := _elna_tac_instruction_size(); + result := _allocate(instruction_size); + + _elna_tac_instruction_set_kind(result, kind); + _elna_tac_instruction_set_next(result, 0); + + return result +end; + +proc _elna_tac_module_create(data: Word, code: Word); +var + result: Word; + result_size: Word; +begin + result_size := _elna_tac_module_size(); + result := _allocate(result_size); + + _elna_tac_module_set_data(result, data); + _elna_tac_module_set_code(result, code); + + return result +end; + +proc _elna_tac_load_immediate(target_register: Word, source_immediate: Word, immediate_length: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.load_immediate); + + _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_tac_load_address(target_register: Word, source_symbol: Word, symbol_length: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.load_address); + + _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_tac_beqz(target_register: Word, source_symbol: Word, symbol_length: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.beqz); + + _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_tac_jump(source_symbol: Word, symbol_length: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.jump); + + _elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.symbol, source_symbol, symbol_length); + + return result +end; + +proc _elna_tac_add(destination: Word, lhs: Word, rhs: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.add); + + _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_tac_mul(destination: Word, lhs: Word, rhs: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.mul); + + _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_tac_sub(destination: Word, lhs: Word, rhs: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.sub); + + _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_tac_div(destination: Word, lhs: Word, rhs: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.div); + + _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_tac_rem(destination: Word, lhs: Word, rhs: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.rem); + + _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_tac_xor(destination: Word, lhs: Word, rhs: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator._xor); + + _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_tac_xor_immediate(destination: Word, lhs: Word, rhs: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator._xor); + + _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_tac_or(destination: Word, lhs: Word, rhs: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator._or); + + _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_tac_and(destination: Word, lhs: Word, rhs: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.and); + + _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_tac_add_immediate(destination: Word, lhs: Word, rhs: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.add_immediate); + + _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_tac_slt(destination: Word, lhs: Word, rhs: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.slt); + + _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_tac_jal(symbol: Word, length: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.jal); + + _elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.symbol, symbol, length); + + return result +end; + +proc _elna_tac_load_word(target: Word, register: Word, offset: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.load_word); + + _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_tac_store_word(target: Word, register: Word, offset: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.store_word); + + _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_tac_move(destination: Word, source: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.move); + + _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_tac_seqz(destination: Word, source: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.seqz); + + _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_tac_snez(destination: Word, source: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.snez); + + _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_tac_neg(destination: Word, source: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.neg); + + _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_tac_not(destination: Word, source: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.not); + + _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_tac_label(counter: Word, length: Word); +var + result: Word; +begin + result := _elna_tac_instruction_create(ElnaTacOperator.label); + + _elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.symbol, counter, length); + + return result +end; + +proc _elna_writer_instruction_name(instruction_kind: Word); +var + argument_count: Word; +begin + if instruction_kind = ElnaTacOperator.load_immediate then + argument_count := 2; + _write_s("\tli", 3) + elsif instruction_kind = ElnaTacOperator.load_address then + argument_count := 2; + _write_s("\tla", 3) + elsif instruction_kind = ElnaTacOperator.add then + argument_count := 3; + _write_s("\tadd", 4) + elsif instruction_kind = ElnaTacOperator.add_immediate then + argument_count := 3; + _write_s("\taddi", 5) + elsif instruction_kind = ElnaTacOperator.load_word then + argument_count := 2; + _write_s("\tlw", 3) + elsif instruction_kind = ElnaTacOperator.store_word then + argument_count := 2; + _write_s("\tsw", 3) + elsif instruction_kind = ElnaTacOperator.jal then + argument_count := 1; + _write_s("\tcall", 5) + elsif instruction_kind = ElnaTacOperator.move then + argument_count := 2; + _write_s("\tmv", 3) + elsif instruction_kind = ElnaTacOperator.sub then + argument_count := 3; + _write_s("\tsub", 4) + elsif instruction_kind = ElnaTacOperator.mul then + argument_count := 3; + _write_s("\tmul", 4) + elsif instruction_kind = ElnaTacOperator.div then + argument_count := 3; + _write_s("\tdiv", 4) + elsif instruction_kind = ElnaTacOperator.rem then + argument_count := 3; + _write_s("\trem", 4) + elsif instruction_kind = ElnaTacOperator._xor then + argument_count := 3; + _write_s("\txor", 4) + elsif instruction_kind = ElnaTacOperator.xor_immediate then + argument_count := 3; + _write_s("\txori", 5) + elsif instruction_kind = ElnaTacOperator._or then + argument_count := 3; + _write_s("\tor", 3) + elsif instruction_kind = ElnaTacOperator.and then + argument_count := 3; + _write_s("\tand", 4) + elsif instruction_kind = ElnaTacOperator.seqz then + argument_count := 2; + _write_s("\tseqz", 5) + elsif instruction_kind = ElnaTacOperator.snez then + argument_count := 2; + _write_s("\tsnez", 5) + elsif instruction_kind = ElnaTacOperator.slt then + argument_count := 3; + _write_s("\tslt", 4) + elsif instruction_kind = ElnaTacOperator.neg then + argument_count := 2; + _write_s("\tneg", 4) + elsif instruction_kind = ElnaTacOperator.not then + argument_count := 2; + _write_s("\tnot", 4) + elsif instruction_kind = ElnaTacOperator.jump then + argument_count := 1; + _write_s("\tj", 2) + elsif instruction_kind = ElnaTacOperator.beqz then + argument_count := 2; + _write_s("\tbeqz", 5) + elsif instruction_kind = ElnaTacOperator.start then + argument_count := 0; + _write_z("\taddi sp, sp, -128\n\tsw ra, 124(sp)\n\tsw s0, 120(sp)\n\taddi s0, sp, 128\0") + elsif instruction_kind = ElnaTacOperator.ret then + argument_count := 0; + _write_z("\tlw ra, 124(sp)\n\tlw s0, 120(sp)\n\taddi sp, sp, 128\0") + end; + return argument_count +end; + +proc _elna_writer_register(register: Word); +begin + _write_c('x'); + _write_i(register - 1) +end; + +proc _elna_writer_operand(instruction: Word, n: Word); +var + operand_value: Word; + operand_length: Word; + operand_type: Word; +begin + 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 = ElnaTacOperand.register then + _elna_writer_register(operand_value) + elsif operand_type = ElnaTacOperand.offset then + _write_i(operand_length); + _write_c('('); + _elna_writer_register(operand_value); + _write_c(')') + 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 (* ElnaTacOperand.immediate *) + _write_i(operand_value) + else + _write_s(operand_value, operand_length) + end +end; + +proc _elna_writer_instruction(instruction: Word); +var + instruction_kind: Word; + argument_count: Word; + current_argument: Word; + operand_value: Word; + operand_length: Word; +begin + instruction_kind := _elna_tac_instruction_get_kind(instruction); + + if instruction_kind = ElnaTacOperator.label then + argument_count := 0; + 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 + argument_count := _elna_writer_instruction_name(instruction_kind) + end; + current_argument := 1; + + .elna_writer_instruction_loop; + if current_argument <= argument_count then + _elna_writer_operand(instruction, current_argument); + current_argument := current_argument + 1 + end; + if current_argument <= argument_count then + _write_c(','); + goto elna_writer_instruction_loop + end; + + _write_c('\n') +end; + +proc _elna_writer_instructions(instruction: Word); +begin + if instruction <> 0 then + _elna_writer_instruction(instruction); + instruction := _elna_tac_instruction_get_next(instruction); + _elna_writer_instructions(instruction) + end +end; + +proc _elna_writer_procedure(procedure: Word); +var + name_pointer: Word; + name_length: Word; + body_statements: Word; +begin + .elna_writer_procedure_loop; + 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"); + + _write_s(name_pointer, name_length); + _write_z(", @function\n\0"); + + (* Write procedure label, _procedure_name: *) + _write_s(name_pointer, name_length); + _write_z(":\n\0"); + + _elna_writer_instructions(body_statements); + _write_z("\tret\n\0"); + + procedure := _elna_tac_declaration_get_next(procedure); + if procedure <> 0 then + goto elna_writer_procedure_loop + end +end; + +proc _elna_writer_variable(variable: Word); +var + name: Word; + name_length: Word; + size: Word; +begin + .elna_writer_variable_loop; + if variable <> 0 then + 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); + _write_z(", @object\n\0"); + + _write_s(name, name_length); + _write_c(':'); + + _write_z(" .zero \0"); + _write_i(size); + + _write_c('\n'); + variable := _elna_tac_declaration_get_next(variable); + + goto elna_writer_variable_loop + end +end; + +proc _elna_writer_module(pair: Word); +var + compiler_strings_copy: Word; + compiler_strings_end: Word; + current_byte: Word; + current_part: Word; +begin + _write_z(".globl _start\n\n\0"); + _write_z(".section .data\n\0"); + + current_part := _elna_tac_module_get_data(pair); + _elna_writer_variable(current_part); + + _write_z(".section .text\n\n\0"); + _write_z(".type _syscall, @function\n_syscall:\n\tmv a7, a6\n\tecall\n\tret\n\n\0"); + _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_tac_module_get_code(pair); + _elna_writer_procedure(current_part); + + _write_z(".section .rodata\n.type strings, @object\nstrings: .ascii \0"); + _write_c('"'); + + compiler_strings_copy := @compiler_strings; + compiler_strings_end := compiler_strings_position; + + .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 elna_writer_module_loop + end; + _write_c('"'); + _write_c('\n'); +end; + +proc _elna_parser_integer_literal(); +var + integer_token: Word; + integer_length: Word; + result: Word; + literal_size: Word; +begin + literal_size := _integer_literal_node_size(); + result := _allocate(literal_size); + + integer_token := _elna_lexer_global_get_start(); + integer_length := _elna_lexer_global_get_end(); + integer_length := integer_length - integer_token; + _elna_lexer_skip_token(); + + _node_set_kind(result, NodeKind.integer_literal); + _integer_literal_node_set_value(result, integer_token); + _integer_literal_node_set_length(result, integer_length); + + return result +end; + +proc _elna_tac_integer_literal(integer_literal_node: Word); +var + integer_token: Word; + integer_length: Word; + token_kind: Word; +begin + integer_token := _integer_literal_node_get_value(integer_literal_node); + integer_length := _integer_literal_node_get_length(integer_literal_node); + + return _elna_tac_load_immediate(ElnaTacRegister.t0, integer_token, integer_length) +end; + +proc _elna_parser_character_literal(); +var + character: Word; + character_length: Word; + result: Word; + literal_size: Word; +begin + literal_size := _character_literal_node_size(); + result := _allocate(literal_size); + + character := _elna_lexer_global_get_start(); + character_length := _elna_lexer_global_get_end(); + character_length := character_length - character; + _elna_lexer_skip_token(); + + _node_set_kind(result, NodeKind.character_literal); + _integer_literal_node_set_value(result, character); + _integer_literal_node_set_length(result, character_length); + + return result +end; + +proc _elna_tac_character_literal(character_literal_node: Word); +var + character: Word; + character_length: Word; +begin + character := _character_literal_node_get_value(character_literal_node); + character_length := _character_literal_node_get_length(character_literal_node); + + return _elna_tac_load_immediate(ElnaTacRegister.t0, character, character_length) +end; + +proc _allocate(size: Word); +var + result: Word; +begin + result := memory_free_pointer; + memory_free_pointer := memory_free_pointer + size; + return result +end; + +proc _elna_parser_variable_expression(); +var + name: Word; + name_token: Word; + result: Word; + memory_size: Word; +begin + name := _elna_lexer_global_get_start(); + name_token := _elna_lexer_global_get_end(); + name_token := name_token - name; + _elna_lexer_skip_token(); + + memory_size := _variable_expression_size(); + result := _allocate(memory_size); + + _node_set_kind(result, NodeKind.variable_expression); + _variable_expression_set_name(result, name); + _variable_expression_set_length(result, name_token); + + return result +end; + +proc _elna_tac_variable_expression(variable_expression: Word, symbol_table: Word); +var + name: Word; + name_token: Word; + lookup_result: Word; + instruction: Word; +begin + name := _variable_expression_get_name(variable_expression); + name_token := _variable_expression_get_length(variable_expression); + + lookup_result := _symbol_table_lookup(symbol_table, name, name_token); + if lookup_result <> 0 then + instruction := _elna_tac_local_designator(lookup_result) + else + instruction := _elna_tac_global_designator(variable_expression) + end; + return instruction +end; + +proc _elna_parser_string_literal(); +var + length: Word; + token_start: Word; + result: Word; + memory_size: Word; +begin + memory_size := _string_literal_node_size(); + result := _allocate(memory_size); + + token_start := _elna_lexer_global_get_start(); + length := _string_length(token_start); + _elna_lexer_skip_token(); + + _node_set_kind(result, NodeKind.string_literal); + _string_literal_node_set_value(result, token_start); + _string_literal_node_set_length(result, length); + + return result +end; + +proc _elna_tac_string_literal(string_literal_node: Word); +var + token_start: Word; + length: Word; + offset: Word; + instruction: Word; + first_instruction: Word; + next_instruction: Word; +begin + token_start := _string_literal_node_get_value(string_literal_node); + length := _string_literal_node_get_length(string_literal_node); + offset := _add_string(token_start); + + 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; + +proc _elna_parser_simple_expression(); +var + current_character: Word; + parser_node: Word; + token_kind: Word; +begin + parser_node := 0; + _elna_lexer_read_token(@token_kind); + + if token_kind = ElnaLexerKind.character then + parser_node := _elna_parser_character_literal() + elsif token_kind = ElnaLexerKind.integer then + parser_node := _elna_parser_integer_literal() + elsif token_kind = ElnaLexerKind.string then + parser_node := _elna_parser_string_literal() + elsif token_kind = ElnaLexerKind.identifier then + parser_node := _elna_parser_variable_expression() + end; + return parser_node +end; + +proc _elna_parser_dereference_expression(simple_expression: Word); +var + result: Word; + memory_size: Word; +begin + memory_size := _dereference_expression_size(); + result := _allocate(memory_size); + + _node_set_kind(result, NodeKind.dereference_expression); + _dereference_expression_set_pointer(result, simple_expression); + _elna_lexer_skip_token(); + + return result +end; + +proc _elna_parser_designator(); +var + simple_expression: Word; + token_kind: Word; +begin + simple_expression := _elna_parser_simple_expression(); + + _elna_lexer_read_token(@token_kind); + + if token_kind = ElnaLexerKind.hat then + simple_expression := _elna_parser_dereference_expression(simple_expression) + elsif token_kind = ElnaLexerKind.dot then + simple_expression := _elna_parser_field_access_expression(simple_expression) + elsif token_kind = ElnaLexerKind.left_paren then + simple_expression := _elna_parser_call(simple_expression) + end; + return simple_expression +end; + +proc _elna_tac_simple_expression(parser_node: Word, symbol_table: Word, is_address: Word); +var + is_address: Word; + node_kind: Word; + instruction: Word; +begin + is_address^ := 0; + node_kind := _node_get_kind(parser_node); + + if node_kind = NodeKind.character_literal then + instruction := _elna_tac_character_literal(parser_node) + elsif node_kind = NodeKind.string_literal then + instruction := _elna_tac_string_literal(parser_node) + elsif node_kind = NodeKind.integer_literal then + instruction := _elna_tac_integer_literal(parser_node) + else + instruction := _elna_tac_variable_expression(parser_node, symbol_table); + is_address^ := 1 + end; + return instruction +end; + +proc _elna_parser_unary_expression(); +var + token_kind: Word; + result: Word; + memory_size: Word; + operand: Word; + operator: Word; +begin + _elna_lexer_read_token(@token_kind); + operator := 0; + + if token_kind = ElnaLexerKind.at then + operator := '@' + elsif token_kind = ElnaLexerKind.minus then + operator := '-' + elsif token_kind = ElnaLexerKind.not then + operator := '~' + end; + if operator <> 0 then + _elna_lexer_skip_token() + end; + result := _elna_parser_designator(); + + if operator <> 0 then + operand := result; + memory_size := _unary_expression_size(); + result := _allocate(memory_size); + + _node_set_kind(result, NodeKind.unary_expression); + _unary_expression_set_operand(result, operand); + _unary_expression_set_operator(result, operator) + end; + + return result +end; + +proc _elna_tac_unary_expression(parser_node: Word, symbol_table: Word); +var + current_character: Word; + token_kind: Word; + expression_kind: Word; + operator: Word; + operand: Word; + is_address: Word; + first_instruction: Word; + instruction: Word; +begin + operator := 0; + operand := 0; + + expression_kind := _node_get_kind(parser_node); + + if expression_kind = NodeKind.unary_expression then + operator := _unary_expression_get_operator(parser_node); + operand := _unary_expression_get_operand(parser_node) + else + operand := parser_node + end; + + if operator = '@' then + first_instruction := _elna_tac_designator(operand, symbol_table, @is_address) + else + first_instruction := _elna_tac_designator(operand, symbol_table, @is_address); + if is_address then + 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_tac_neg(ElnaTacRegister.t0, ElnaTacRegister.t0); + _elna_tac_instruction_set_next(first_instruction, instruction) + elsif operator = '~' then + instruction := _elna_tac_not(ElnaTacRegister.t0, ElnaTacRegister.t0); + _elna_tac_instruction_set_next(first_instruction, instruction) + end; + return first_instruction +end; + +proc _elna_parser_binary_expression(); +var + lhs_node: Word; + rhs_node: Word; + token_kind: Word; + memory_size: Word; + result: Word; +begin + lhs_node := _elna_parser_unary_expression(); + rhs_node := 0; + _elna_lexer_read_token(@token_kind); + + if token_kind = ElnaLexerKind.plus then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.minus then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.multiplication then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.and then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind._or then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind._xor then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.equals then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.remainder then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.division then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.less_than then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.greater_than then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.less_equal then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.not_equal then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + elsif token_kind = ElnaLexerKind.greater_equal then + _elna_lexer_skip_token(); + rhs_node := _elna_parser_unary_expression() + end; + if rhs_node <> 0 then + memory_size := _binary_expression_size(); + result := _allocate(memory_size); + + _node_set_kind(result, NodeKind.binary_expression); + _binary_expression_set_lhs(result, lhs_node); + _binary_expression_set_rhs(result, rhs_node); + _binary_expression_set_operator(result, token_kind) + else + result := lhs_node + end; + return result +end; + +proc _elna_tac_binary_expression(parser_node: Word, symbol_table: Word); +var + token_kind: Word; + expression_kind: Word; + operand_node: Word; + first_instruction: Word; + instruction: Word; + current_instruction: Word; +begin + expression_kind := _node_get_kind(parser_node); + + if expression_kind <> NodeKind.binary_expression then + 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 := _elna_tac_unary_expression(operand_node, symbol_table); + + (* Save the value of the left expression on the stack. *) + 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 := _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_tac_load_word(ElnaTacRegister.t1, ElnaTacRegister.sp, 64); + _elna_tac_instruction_set_next(current_instruction, instruction); + current_instruction := instruction; + + if token_kind = ElnaLexerKind.plus then + instruction := _elna_tac_add(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); + _elna_tac_instruction_set_next(current_instruction, instruction) + elsif token_kind = ElnaLexerKind.minus then + instruction := _elna_tac_sub(ElnaTacRegister.t0, ElnaTacRegister.t1, ElnaTacRegister.t0); + _elna_tac_instruction_set_next(current_instruction, instruction) + elsif token_kind = ElnaLexerKind.multiplication then + instruction := _elna_tac_mul(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); + _elna_tac_instruction_set_next(current_instruction, instruction) + elsif token_kind = ElnaLexerKind.and then + instruction := _elna_tac_and(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); + _elna_tac_instruction_set_next(current_instruction, instruction) + elsif token_kind = ElnaLexerKind._or then + instruction := _elna_tac_or(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); + _elna_tac_instruction_set_next(current_instruction, instruction) + elsif token_kind = ElnaLexerKind._xor then + instruction := _elna_tac_xor(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); + _elna_tac_instruction_set_next(current_instruction, instruction) + elsif token_kind = ElnaLexerKind.equals then + instruction := _elna_tac_xor(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); + _elna_tac_instruction_set_next(current_instruction, instruction); + current_instruction := instruction; + + instruction := _elna_tac_seqz(ElnaTacRegister.t0, ElnaTacRegister.t0); + _elna_tac_instruction_set_next(current_instruction, instruction) + elsif token_kind = ElnaLexerKind.remainder then + instruction := _elna_tac_rem(ElnaTacRegister.t0, ElnaTacRegister.t1, ElnaTacRegister.t0); + _elna_tac_instruction_set_next(current_instruction, instruction) + elsif token_kind = ElnaLexerKind.division then + instruction := _elna_tac_div(ElnaTacRegister.t0, ElnaTacRegister.t1, ElnaTacRegister.t0); + _elna_tac_instruction_set_next(current_instruction, instruction) + elsif token_kind = ElnaLexerKind.less_than then + instruction := _elna_tac_slt(ElnaTacRegister.t0, ElnaTacRegister.t1, ElnaTacRegister.t0); + _elna_tac_instruction_set_next(current_instruction, instruction) + elsif token_kind = ElnaLexerKind.greater_than then + instruction := _elna_tac_slt(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); + _elna_tac_instruction_set_next(current_instruction, instruction) + elsif token_kind = ElnaLexerKind.less_equal then + instruction := _elna_tac_slt(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); + _elna_tac_instruction_set_next(current_instruction, instruction); + current_instruction := instruction; + + instruction := _elna_tac_xor_immediate(ElnaTacRegister.t0, ElnaTacRegister.t0, 1); + _elna_tac_instruction_set_next(current_instruction, instruction) + elsif token_kind = ElnaLexerKind.not_equal then + instruction := _elna_tac_xor(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1); + _elna_tac_instruction_set_next(current_instruction, instruction); + current_instruction := instruction; + + instruction := _elna_tac_snez(ElnaTacRegister.t0, ElnaTacRegister.t0); + _elna_tac_instruction_set_next(current_instruction, instruction) + elsif token_kind = ElnaLexerKind.greater_equal then + instruction := _elna_tac_slt(ElnaTacRegister.t0, ElnaTacRegister.t1, ElnaTacRegister.t0); + _elna_tac_instruction_set_next(current_instruction, instruction); + current_instruction := instruction; + + instruction := _elna_tac_xor_immediate(ElnaTacRegister.t0, ElnaTacRegister.t0, 1); + _elna_tac_instruction_set_next(current_instruction, instruction) + end + end; + return first_instruction +end; + +(* 4 bytes node kind + 4 byte pointer to variable expression + 4 * 7 for arguments. *) +proc _call_size(); + return 44 +end; + +proc _call_get_name(this: Word); +begin + this := this + 8; + return this^ +end; + +proc _call_set_name(this: Word, value: Word); +begin + this := this + 8; + this^ := value +end; + +proc _call_get_argument(this: Word, n: Word); +begin + n := n * 4; + this := this + 8; + this := this + n; + return this^ +end; + +proc _call_set_argument(this: Word, n: Word, value: Word); +begin + n := n * 4; + this := this + 8; + this := this + n; + this^ := value +end; + +proc _elna_parser_call(callee: Word); +var + parsed_expression: Word; + result: Word; + argument_number: Word; + token_kind: Word; + call_size: Word; +begin + call_size := _call_size(); + result := _allocate(call_size); + _node_set_kind(result, NodeKind.call); + _statement_set_next(result, 0); + + argument_number := 1; + _call_set_name(result, callee); + + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + + if token_kind = ElnaLexerKind.right_paren then + _elna_lexer_skip_token(); + goto elna_parser_call_end + end; + + .elna_parser_call_loop; + parsed_expression := _elna_parser_binary_expression(); + _call_set_argument(result, argument_number, parsed_expression); + argument_number := argument_number + 1; + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + if token_kind = ElnaLexerKind.comma then + goto elna_parser_call_loop + end; + + .elna_parser_call_end; + (* Set the trailing argument to nil. *) + _call_set_argument(result, argument_number, 0); + + return result +end; + +proc _elna_tac_call(parsed_call: Word, symbol_table: Word); +var + name_length: Word; + name: Word; + argument_count: Word; + stack_offset: Word; + parsed_expression: Word; + instruction: Word; + first_instruction: Word; + current_instruction: Word; +begin + parsed_expression := _call_get_name(parsed_call); + name := _variable_expression_get_name(parsed_expression); + name_length := _variable_expression_get_length(parsed_expression); + argument_count := 0; + first_instruction := 0; + + .elna_tac_call_loop; + + parsed_expression := _call_get_argument(parsed_call, argument_count + 1); + if parsed_expression = 0 then + goto elna_tac_call_finalize + else + instruction := _elna_tac_binary_expression(parsed_expression, symbol_table); + if first_instruction = 0 then + first_instruction := instruction + else + _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_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 elna_tac_call_loop + end; + .elna_tac_call_finalize; + + (* Load the argument from the stack. *) + if argument_count <> 0 then + (* Decrement the argument counter. *) + argument_count := argument_count - 1; + stack_offset := argument_count * 4; + + (* Calculate the stack offset: 116 - (4 * argument_counter) *) + 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 elna_tac_call_finalize + end; + instruction := _elna_tac_jal(name, name_length); + if first_instruction = 0 then + first_instruction := instruction + else + _elna_tac_instruction_set_next(current_instruction, instruction) + end; + return first_instruction +end; + +proc _elna_parser_goto_statement(); +var + token_kind: Word; + label_name: Word; + label_length: Word; + statement_size: Word; + result: Word; +begin + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + + label_name := _elna_lexer_global_get_start(); + label_length := _elna_lexer_global_get_end() - label_name; + _elna_lexer_skip_token(); + + statement_size := _goto_statement_size(); + result := _allocate(statement_size); + + _node_set_kind(result, NodeKind.goto_statement); + _statement_set_next(result, 0); + _goto_statement_set_label(result, label_name); + _goto_statement_set_length(result, label_length); + + return result +end; + +proc _elna_tac_goto_statement(parser_node: Word); +var + label_name: Word; + label_length: Word; + label_with_dot: Word; + instruction: Word; +begin + label_name := _goto_statement_get_label(parser_node); + label_length := _goto_statement_get_length(parser_node); + label_with_dot := _allocate(label_length + 1); + + _store_byte('.', label_with_dot); + _memcpy(label_with_dot + 1, label_name, label_length); + + return _elna_tac_jump(label_with_dot, label_length + 1) +end; + +proc _elna_parser_label_declaration(); +var + token_kind: Word; + label_name: Word; + label_length: Word; + statement_size: Word; + result: Word; +begin + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + + label_name := _elna_lexer_global_get_start(); + label_length := _elna_lexer_global_get_end() - label_name; + _elna_lexer_skip_token(); + + statement_size := _label_declaration_size(); + result := _allocate(statement_size); + + _node_set_kind(result, NodeKind.label_declaration); + _statement_set_next(result, 0); + _goto_statement_set_label(result, label_name); + _goto_statement_set_length(result, label_length); + + return result +end; + +proc _elna_tac_label_declaration(parser_node: Word); +var + label_name: Word; + label_length: Word; +begin + label_name := _label_declaration_get_label(parser_node); + label_length := _label_declaration_get_length(parser_node); + + return _elna_tac_label(label_name, label_length) +end; + +proc _elna_tac_local_designator(symbol: Word); +var + variable_offset: Word; +begin + variable_offset := _parameter_info_get_offset(symbol); + + return _elna_tac_add_immediate(ElnaTacRegister.t0, ElnaTacRegister.sp, variable_offset) +end; + +proc _elna_tac_global_designator(variable_expression: Word); +var + name: Word; + token_length: Word; +begin + name := _variable_expression_get_name(variable_expression); + token_length := _variable_expression_get_length(variable_expression); + + return _elna_tac_load_address(ElnaTacRegister.t0, name, token_length) +end; + +proc _elna_tac_enumeration_value(field_access_expression: Word); +var + enumeration_type: Word; + members: Word; + members_length: Word; + token_type: Word; + value_name: Word; + name_length: Word; + member_name: Word; + member_length: Word; + counter: Word; + symbol: Word; + instruction: Word; +begin + symbol := _field_access_expression_get_aggregate(field_access_expression); + value_name := _variable_expression_get_name(symbol); + name_length := _variable_expression_get_length(symbol); + + symbol := _symbol_table_lookup(@symbol_table_global, value_name, name_length); + + enumeration_type := _type_info_get_type(symbol); + members := _enumeration_type_get_members(enumeration_type); + members_length := _enumeration_type_get_length(enumeration_type); + + _elna_lexer_read_token(@token_type); + + value_name := _field_access_expression_get_field(field_access_expression); + name_length := _field_access_expression_get_length(field_access_expression); + counter := 1; + + instruction := 0; + .elna_tac_enumeration_value_members; + if members_length > 0 then + member_name := members^; + member_length := members + 4; + member_length := member_length^; + + if _string_compare(value_name, name_length, member_name, member_length) = 0 then + members_length := members_length - 1; + members := members + 8; + counter := counter + 1; + goto elna_tac_enumeration_value_members + end; + instruction := _elna_tac_load_immediate(ElnaTacRegister.t0, counter, 0) + end; + return instruction +end; + +proc _elna_parser_field_access_expression(aggregate: Word); +var + token_kind: Word; + name: Word; + name_token: Word; + result: Word; + memory_size: Word; +begin + (* Skip dot. Read the enumeration value. *) + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + + name := _elna_lexer_global_get_start(); + name_token := _elna_lexer_global_get_end(); + name_token := name_token - name; + _elna_lexer_skip_token(); + memory_size := _field_access_expression_size(); + result := _allocate(memory_size); + + _node_set_kind(result, NodeKind.field_access_expression); + _field_access_expression_set_aggregate(result, aggregate); + _field_access_expression_set_field(result, name); + _field_access_expression_set_length(result, name_token); + + return result +end; + +proc _elna_tac_designator(parser_node: Word, symbol_table: Word, is_address: Word); +var + name_token: Word; + lookup_result: Word; + token_kind: Word; + parser_node: Word; + node_kind: Word; + first_instruction: Word; + instruction: Word; +begin + node_kind := _node_get_kind(parser_node); + + if node_kind = NodeKind.dereference_expression then + parser_node := _dereference_expression_get_pointer(parser_node); + 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 := _elna_tac_enumeration_value(parser_node); + is_address^ := 0 + elsif node_kind = NodeKind.call then + 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 := _elna_tac_simple_expression(parser_node, symbol_table, is_address) + end; + return first_instruction +end; + +proc _elna_parser_assign_statement(assignee: Word); +var + statement_size: Word; + result: Word; + token_kind: Word; + assignment_node: Word; +begin + statement_size := _assign_statement_size(); + result := _allocate(statement_size); + + _node_set_kind(result, NodeKind.assign_statement); + _statement_set_next(result, 0); + _assign_statement_set_assignee(result, assignee); + + (* Skip the assignment sign (:=) with surrounding whitespaces. *) + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + assignment_node := _elna_parser_binary_expression(); + _assign_statement_set_assignment(result, assignment_node); + + return result +end; + +proc _elna_tac_assign_statement(parser_tree: Word, symbol_table: Word); +var + current_expression: Word; + is_address: Word; + first_instruction: Word; + instruction: Word; + current_instruction: Word; +begin + current_expression := _assign_statement_get_assignee(parser_tree); + first_instruction := _elna_tac_designator(current_expression, symbol_table, @is_address); + + (* Save the assignee address on the stack. *) + 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 := _elna_tac_binary_expression(current_expression, symbol_table); + _elna_tac_instruction_set_next(current_instruction, instruction); + + current_instruction := _elna_tac_load_word(ElnaTacRegister.t1, ElnaTacRegister.sp, 60); + _elna_tac_instruction_set_next(instruction, current_instruction); + + instruction := _elna_tac_store_word(ElnaTacRegister.t0, ElnaTacRegister.t1, 0); + _elna_tac_instruction_set_next(current_instruction, instruction); + + return first_instruction +end; + +proc _elna_parser_return_statement(); +var + token_kind: Word; + returned: Word; + label_length: Word; + statement_size: Word; + result: Word; +begin + (* Skip "return" keyword and whitespace after it. *) + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + + returned := _elna_parser_binary_expression(); + + statement_size := _return_statement_size(); + result := _allocate(statement_size); + + _node_set_kind(result, NodeKind.return_statement); + _statement_set_next(result, 0); + _return_statement_set_returned(result, returned); + + return result +end; + +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 := _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; + +(** + * Writes a label, .Ln, where n is a unique number. + * + * Parameters: + * counter - Label counter. + *) +proc _write_label(counter: Word, length: Word); +var + first_byte: Word; +begin + if length = 0 then + _write_s(".L", 2); + _write_i(counter) + else + first_byte := _load_byte(counter); + if first_byte <> '.' then + _write_c('.') + end; + _write_s(counter, length) + end +end; + +proc _elna_parser_conditional_statements(); +var + conditional_size: Word; + token_kind: Word; + current_node: Word; + result: Word; +begin + conditional_size := _conditional_statements_size(); + result := _allocate(conditional_size); + + (* Skip "if", "while" or "elsif". *) + _elna_lexer_skip_token(); + + current_node := _elna_parser_binary_expression(); + _conditional_statements_set_condition(result, current_node); + + (* Skip "then" or "do". *) + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + current_node := _elna_parser_statements(); + _conditional_statements_set_statements(result, current_node); + + _conditional_statements_set_next(result, 0); + return result +end; + +proc _elna_tac_conditional_statements(parser_node: Word, after_end_label: Word, symbol_table: Word); +var + condition_label: Word; + current_node: Word; + instruction: Word; + current_instruction: Word; + first_instruction: Word; +begin + (* Compile condition. *) + current_node := _conditional_statements_get_condition(parser_node); + 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_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 := _elna_tac_statements(current_node, symbol_table); + if instruction <> 0 then + _elna_tac_instruction_set_next(current_instruction, instruction); + current_instruction := instruction + end; + + instruction := _elna_tac_jump(after_end_label, 0); + _elna_tac_instruction_set_next(current_instruction, instruction); + + current_instruction := _elna_tac_label(condition_label, 0); + _elna_tac_instruction_set_next(instruction, current_instruction); + + return first_instruction +end; + +proc _elna_parser_if_statement(); +var + current_node: Word; + result: Word; + object_size: Word; + token_kind: Word; + previous_conditional: Word; + next_conditional: Word; +begin + object_size := _if_statement_size(); + result := _allocate(object_size); + + _node_set_kind(result, NodeKind.if_statement); + _statement_set_next(result, 0); + + previous_conditional := _elna_parser_conditional_statements(); + _if_statement_set_conditionals(result, previous_conditional); + + .elna_parser_if_statement_loop; + _elna_lexer_read_token(@token_kind); + + if token_kind = ElnaLexerKind._elsif then + next_conditional := _elna_parser_conditional_statements(); + _conditional_statements_set_next(previous_conditional, next_conditional); + previous_conditional = next_conditional; + + goto elna_parser_if_statement_loop + elsif token_kind = ElnaLexerKind._else then + _elna_lexer_skip_token(); + + current_node := _elna_parser_statements(); + _if_statement_set__else(result, current_node) + else + _if_statement_set__else(result, 0) + end; + _elna_lexer_skip_token(); + + return result +end; + +proc _elna_parser_statement(); +var + token_kind: Word; + result : Word; +begin + result := 0; + _elna_lexer_read_token(@token_kind); + + if token_kind = ElnaLexerKind._goto then + result := _elna_parser_goto_statement() + elsif token_kind = ElnaLexerKind._if then + result := _elna_parser_if_statement() + elsif token_kind = ElnaLexerKind._return then + result := _elna_parser_return_statement() + elsif token_kind = ElnaLexerKind.dot then + result := _elna_parser_label_declaration() + elsif token_kind = ElnaLexerKind.identifier then + result := _elna_parser_designator(); + + if _node_get_kind(result) <> NodeKind.call then + result := _elna_parser_assign_statement(result) + end + end; + return result +end; + +proc _elna_parser_statements(); +var + token_kind: Word; + previous_statement: Word; + next_statement: Word; + first_statement: Word; +begin + _skip_empty_lines(); + + first_statement := _elna_parser_statement(); + previous_statement := first_statement; + if previous_statement = 0 then + goto elna_parser_statements_end + end; + + .elna_parser_statement_loop; + _elna_lexer_read_token(@token_kind); + + if token_kind = ElnaLexerKind.semicolon then + _elna_lexer_skip_token(); + _skip_empty_lines(); + next_statement := _elna_parser_statement(); + _statement_set_next(previous_statement, next_statement); + previous_statement := next_statement; + + if previous_statement <> 0 then + goto elna_parser_statement_loop + end + end; + .elna_parser_statements_end; + _skip_empty_lines(); + + return first_statement +end; + +proc _elna_tac_statements(parser_node: Word, symbol_table: Word); +var + current_statement: Word; + instruction: Word; + first_instruction: Word; + current_instruction: Word; +begin + current_statement := parser_node; + first_instruction := 0; + + .elna_tac_statements_loop; + if current_statement <> 0 then + instruction := _elna_tac_statement(current_statement, symbol_table); + current_statement := _statement_get_next(current_statement); + if instruction = 0 then + goto elna_tac_statements_loop + end; + if first_instruction = 0 then + first_instruction := instruction + else + _elna_tac_instruction_set_next(current_instruction, instruction) + end; + current_instruction := instruction; + goto elna_tac_statements_loop + end; + return first_instruction +end; + +proc _elna_tac_if_statement(parser_node: Word, symbol_table: Word); +var + current_node: Word; + after_end_label: Word; + condition_label: Word; + first_instruction: Word; + instruction: Word; + current_instruction: Word; +begin + after_end_label := label_counter; + label_counter := label_counter + 1; + + current_node := _if_statement_get_conditionals(parser_node); + first_instruction := _elna_tac_conditional_statements(current_node, after_end_label, symbol_table); + current_instruction := first_instruction; + + .elna_tac_if_statement_loop; + current_node := _conditional_statements_get_next(current_node); + if current_node <> 0 then + instruction := _elna_tac_conditional_statements(current_node, after_end_label, symbol_table); + _elna_tac_instruction_set_next(current_instruction, instruction); + current_instruction := instruction; + goto elna_tac_if_statement_loop + end; + current_node := _if_statement_get__else(parser_node); + + if current_node <> 0 then + instruction := _elna_tac_statements(current_node, symbol_table); + if instruction <> 0 then + _elna_tac_instruction_set_next(current_instruction, instruction); + current_instruction := instruction + end + end; + instruction := _elna_tac_label(after_end_label, 0); + _elna_tac_instruction_set_next(current_instruction, instruction); + + return first_instruction +end; + +proc _elna_tac_statement(parser_node: Word, symbol_table: Word); +var + statement_kind: Word; + instruction: Word; +begin + statement_kind := _node_get_kind(parser_node); + + if statement_kind = NodeKind.goto_statement then + instruction := _elna_tac_goto_statement(parser_node) + elsif statement_kind = NodeKind.if_statement then + instruction := _elna_tac_if_statement(parser_node, symbol_table) + elsif statement_kind = NodeKind.return_statement then + instruction := _elna_tac_return_statement(parser_node, symbol_table) + elsif statement_kind = NodeKind.label_declaration then + instruction := _elna_tac_label_declaration(parser_node) + elsif statement_kind = NodeKind.call then + instruction := _elna_tac_call(parser_node, symbol_table) + elsif statement_kind = NodeKind.assign_statement then + instruction := _elna_tac_assign_statement(parser_node, symbol_table) + else + instruction := 0 + end; + return instruction +end; + +(** + * Writes a regster name to the standard output. + * + * Parameters: + * register_character - Register character. + * register_number - Register number. + *) +proc _write_register(register_character: Word, register_number: Word); +begin + _write_c(register_character); + _write_c(register_number + '0') +end; + +proc _elna_parser_record_type_expression(); +var + entry: Word; + member_count: Word; + memory_start: Word; + field_name: Word; + field_length: Word; + field_type: Word; + token_kind: Word; + type_expression_size: Word; + result: Word; + previous_entry: Word; +begin + _elna_lexer_skip_token(); + member_count := 0; + memory_start := 0; + + _elna_lexer_read_token(@token_kind); + if token_kind = ElnaLexerKind._end then + goto elna_parser_record_type_expression_end + end; + .elna_parser_record_type_expression_loop; + entry := _allocate(16); + member_count := member_count + 1; + + field_name := _elna_lexer_global_get_start(); + field_length := _elna_lexer_global_get_end() - field_name; + + entry^ := field_name; + entry := entry + 4; + + entry^ := field_length; + entry := entry + 4; + + (* Skip the identifier. *) + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + field_type := _elna_parser_type_expression(); + + entry^ := field_type; + entry := entry + 4; + + entry^ := 0; + if memory_start = 0 then + memory_start := entry - 12 + else + previous_entry^ := entry - 12 + end; + previous_entry := entry; + + _elna_lexer_read_token(@token_kind); + if token_kind = ElnaLexerKind.semicolon then + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + goto elna_parser_record_type_expression_loop + end; + + .elna_parser_record_type_expression_end; + _elna_lexer_skip_token(); + + type_expression_size := _enumeration_type_expression_size(); + result := _allocate(type_expression_size); + + _node_set_kind(result, NodeKind.record_type_expression); + _record_type_expression_set_members(result, memory_start); + _record_type_expression_set_length(result, member_count); + + return result +end; + +proc _elna_parser_enumeration_type_expression(); +var + token_kind: Word; + enumeration_name: Word; + name_length: Word; + memory_start: Word; + member_count: Word; + result: Word; + type_expression_size: Word; + entry: Word; + previous_entry: Word; +begin + _elna_lexer_skip_token(); + memory_start := 0; + member_count := 0; + + _elna_lexer_read_token(@token_kind); + if token_kind = ElnaLexerKind.right_paren then + goto elna_parser_enumeration_type_expression_end + end; + .elna_parser_enumeration_type_expression_loop; + entry := _allocate(12); + member_count := member_count + 1; + + enumeration_name := _elna_lexer_global_get_start(); + name_length := _elna_lexer_global_get_end() - enumeration_name; + + entry^ := enumeration_name; + entry := entry + 4; + + entry^ := name_length; + entry := entry + 4; + + entry^ := 0; + if memory_start = 0 then + memory_start := entry - 8 + else + previous_entry^ := entry - 8 + end; + previous_entry := entry; + + (* Skip the identifier. *) + _elna_lexer_skip_token(); + + _elna_lexer_read_token(@token_kind); + if token_kind = ElnaLexerKind.comma then + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + goto elna_parser_enumeration_type_expression_loop + end; + + .elna_parser_enumeration_type_expression_end; + _elna_lexer_skip_token(); + + type_expression_size := _enumeration_type_expression_size(); + result := _allocate(type_expression_size); + + _node_set_kind(result, NodeKind.enumeration_type_expression); + _enumeration_type_expression_set_members(result, memory_start); + _enumeration_type_expression_set_length(result, member_count); + + return result +end; + +(** + * Reads and creates enumeration type representation. + * + * record + * type_kind: Word; + * size: Word; + * members: StringArray; + * length: Word + * end; + * + * Returns enumeration type description. + *) +proc _elna_name_type_enumeration(parser_node: Word); +var + result: Word; + memory_start: Word; + member_count: Word; + member_array_size: Word; + member_array_start: Word; + member_array_current: Word; +begin + member_array_size := _enumeration_type_size(); + result := _allocate(member_array_size); + + memory_start := _enumeration_type_expression_get_members(parser_node); + member_count := _enumeration_type_expression_get_length(parser_node); + + (* Copy the list of enumeration members into an array of strings. *) + member_array_size := member_count * 8; + member_array_start := _allocate(member_array_size); + member_array_current := member_array_start; + + .elna_name_type_enumeration_loop; + if member_count > 0 then + member_array_current^ := memory_start^; + member_array_current := member_array_current + 4; + memory_start := memory_start + 4; + + member_array_current^ := memory_start^; + member_array_current := member_array_current + 4; + memory_start := memory_start + 4; + + memory_start := memory_start^; + member_count := member_count - 1; + goto elna_name_type_enumeration_loop + end; + member_count := _enumeration_type_expression_get_length(parser_node); + + _type_set_kind(result, TypeKind.enumeration); + _type_set_size(result, 4); + _enumeration_type_set_members(result, member_array_start); + _enumeration_type_set_length(result, member_count); + + return _type_info_create(result) +end; + +proc _elna_name_type_record(parser_node: Word); +var + result: Word; + memory_start: Word; + member_count: Word; + member_array_size: Word; + member_array_start: Word; + member_array_current: Word; +begin + member_array_size := _record_type_size(); + result := _allocate(member_array_size); + + memory_start := _record_type_expression_get_members(parser_node); + member_count := _record_type_expression_get_length(parser_node); + + member_array_size := member_count * 12; + member_array_start := _allocate(member_array_size); + member_array_current := member_array_start; + + .elna_name_type_record_loop; + if member_count > 0 then + member_array_current^ := memory_start^; + member_array_current := member_array_current + 4; + memory_start := memory_start + 4; + + member_array_current^ := memory_start^; + member_array_current := member_array_current + 4; + memory_start := memory_start + 4; + + member_array_current^ := _elna_name_type_expression(memory_start^); + member_array_current := member_array_current + 4; + memory_start := memory_start + 4; + + memory_start := memory_start^; + member_count := member_count - 1; + goto elna_name_type_record_loop + end; + member_count := _record_type_expression_get_length(parser_node); + + _type_set_kind(result, TypeKind._record); + _type_set_size(result, member_count * 4); + _record_type_set_members(result, member_array_start); + _record_type_set_length(result, member_count); + + return _type_info_create(result) +end; + +proc _elna_parser_named_type_expression(); +var + type_expression_size: Word; + result: Word; + type_name: Word; + name_length: Word; +begin + type_expression_size := _named_type_expression_size(); + result := _allocate(type_expression_size); + + _node_set_kind(result, NodeKind.named_type_expression); + type_name := _elna_lexer_global_get_start(); + name_length := _elna_lexer_global_get_end() - type_name; + _named_type_expression_set_name(result, type_name); + _named_type_expression_set_length(result, name_length); + _elna_lexer_skip_token(); + + return result +end; + +proc _elna_parser_type_expression(); +var + token_kind: Word; + result: Word; +begin + result := 0; + _elna_lexer_read_token(@token_kind); + + if token_kind = ElnaLexerKind.identifier then + result := _elna_parser_named_type_expression() + elsif token_kind = ElnaLexerKind.left_paren then + result := _elna_parser_enumeration_type_expression() + elsif token_kind = ElnaLexerKind._record then + result := _elna_parser_record_type_expression() + end; + return result +end; + +proc _elna_name_type_expression(parser_node: Word); +var + token_kind: Word; + type_name: Word; + name_length: Word; + result: Word; +begin + token_kind := _node_get_kind(parser_node); + + if token_kind = NodeKind.named_type_expression then + type_name := _named_type_expression_get_name(parser_node); + name_length := _named_type_expression_get_length(parser_node); + + 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 := _elna_name_type_enumeration(parser_node) + elsif token_kind = NodeKind.record_type_expression then + result := _elna_name_type_record(parser_node) + end; + + return result +end; + +proc _type_info_get_type(this: Word); +begin + this := this + 4; + return this^ +end; + +(** + * Parameters: + * parameter_index - Parameter index. + *) +proc _parameter_info_create(parameter_index: Word); +var + offset: Word; + current_word: Word; + result: Word; +begin + result := _allocate(8); + current_word := result; + current_word^ := InfoKind.parameter_info; + + current_word := current_word + 4; + + (* Calculate the stack offset: 88 - (4 * parameter_counter) *) + offset := parameter_index * 4; + current_word^ := 88 - offset; + + return result +end; + +proc _parameter_info_get_offset(this: Word); +begin + this := this + 4; + return this^ +end; + +proc _type_info_create(type_representation: Word); +var + result: Word; + current_word: Word; +begin + result := _allocate(8); + current_word := result; + current_word^ := InfoKind.type_info; + + current_word := current_word + 4; + current_word^ := type_representation; + + return result +end; + +(** + * Parameters: + * temporary_index - Parameter index. + *) +proc _temporary_info_create(temporary_index: Word); +var + offset: Word; + current_word: Word; + result: Word; +begin + result := _allocate(8); + current_word := result; + current_word^ := InfoKind.temporary_info; + current_word := current_word + 4; + + (* Calculate the stack offset: 4 * variable_counter. *) + current_word^ := temporary_index * 4; + + return result +end; + +(** + * Parameters: + * symbol_table - Local symbol table. + *) +proc _procedure_info_create(symbol_table: Word); +var + current_word: Word; + result: Word; +begin + result := _allocate(8); + current_word := result; + current_word^ := InfoKind.procedure_info; + current_word := current_word + 4; + + current_word^ := symbol_table; + + return result +end; + +proc _procedure_info_get_symbol_table(this: Word); +begin + this := this + 4; + return this^ +end; + +(** + * Parameters: + * parameter_index - Parameter index. + *) +proc _elna_name_procedure_parameter(parser_node: Word, parameter_index: Word, symbol_table: Word); +var + name_length: Word; + info: Word; + name_position: Word; +begin + name_position := _declaration_get_name(parser_node); + name_length := _declaration_get_length(parser_node); + + info := _parameter_info_create(parameter_index); + _symbol_table_enter(symbol_table, name_position, name_length, info) +end; + +(** + * Parameters: + * variable_index - Variable index. + *) +proc _elna_name_procedure_temporary(parser_node: Word, variable_index: Word, symbol_table: Word); +var + name_length: Word; + info: Word; + name_position: Word; +begin + name_position := _declaration_get_name(parser_node); + name_length := _declaration_get_length(parser_node); + + info := _temporary_info_create(variable_index); + _symbol_table_enter(symbol_table, name_position, name_length, info) +end; + +proc _elna_name_procedure_temporaries(parser_node: Word, symbol_table: Word); +var + temporary_counter: Word; +begin + temporary_counter := 0; + + .elna_name_procedure_temporaries_loop; + if parser_node <> 0 then + _elna_name_procedure_temporary(parser_node, temporary_counter, symbol_table); + + temporary_counter := temporary_counter + 1; + parser_node := _declaration_get_next(parser_node); + goto elna_name_procedure_temporaries_loop + end +end; + +proc _elna_parser_procedure_declaration(); +var + name_pointer: Word; + name_length: Word; + token_kind: Word; + result: Word; + declaration_size: Word; + parameter_head: Word; +begin + declaration_size := _procedure_declaration_size(); + result := _allocate(declaration_size); + + _node_set_kind(result, NodeKind.procedure_declaration); + _declaration_set_next(result, 0); + + (* Skip "proc ". *) + _elna_lexer_skip_token(); + + _elna_lexer_read_token(@token_kind); + name_pointer := _elna_lexer_global_get_start(); + name_length := _elna_lexer_global_get_end() - name_pointer; + + _declaration_set_name(result, name_pointer); + _declaration_set_length(result, name_length); + (* Skip procedure name. *) + _elna_lexer_skip_token(); + + (* Skip open paren. *) + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + parameter_head := 0; + + .elna_parser_procedure_declaration_parameter; + _elna_lexer_read_token(@token_kind); + + if token_kind <> ElnaLexerKind.right_paren then + name_pointer := _elna_parser_variable_declaration(); + if parameter_head = 0 then + parameter_head := name_pointer + else + _declaration_set_next(name_length, name_pointer) + end; + name_length := name_pointer; + + _elna_lexer_read_token(@token_kind); + + if token_kind = ElnaLexerKind.comma then + _elna_lexer_skip_token(); + goto elna_parser_procedure_declaration_parameter + end + end; + (* Skip close paren. *) + _elna_lexer_skip_token(); + _procedure_declaration_set_parameters(result, parameter_head); + + (* Skip semicolon and newline. *) + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + parameter_head := _elna_parser_var_part(); + _procedure_declaration_set_temporaries(result, parameter_head); + + (* Skip semicolon, "begin" and newline. *) + _elna_lexer_read_token(@token_kind); + if token_kind = ElnaLexerKind._begin then + _elna_lexer_skip_token(); + parameter_head := _elna_parser_statements() + elsif token_kind = ElnaLexerKind._return then + parameter_head := _elna_parser_return_statement() + end; + _procedure_declaration_set_body(result, parameter_head); + + (* Skip the "end" keyword. *) + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + return result +end; + +proc _elna_tac_parameters(current_parameter: Word, new_symbol_table: Word); +var + name_pointer: Word; + name_length: Word; + parameter_counter: Word; + instruction: Word; + first_instruction: Word; + current_instruction: Word; + symbol_info: Word; +begin + first_instruction := 0; + parameter_counter := 0; + + .elna_tac_parameters_loop; + if current_parameter <> 0 then + name_pointer := _declaration_get_name(current_parameter); + name_length := _declaration_get_length(current_parameter); + symbol_info := _symbol_table_lookup(new_symbol_table, name_pointer, name_length); + + symbol_info := _parameter_info_get_offset(symbol_info); + + 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; + + parameter_counter := parameter_counter + 1; + + current_parameter := _declaration_get_next(current_parameter); + goto elna_tac_parameters_loop + end; + return first_instruction +end; + +proc _elna_tac_procedure_declaration(parser_node: Word); +var + name_pointer: Word; + name_length: Word; + current_parameter: Word; + body: Word; + new_symbol_table: Word; + symbol_info: Word; + instruction: Word; + first_instruction: Word; + result: Word; + result_size: Word; +begin + result_size := _elna_tac_declaration_size(); + result := _allocate(result_size); + + _elna_tac_declaration_set_next(result, 0); + + name_pointer := _declaration_get_name(parser_node); + name_length := _declaration_get_length(parser_node); + + _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_tac_instruction_create(ElnaTacOperator.start); + + current_parameter := _procedure_declaration_get_parameters(parser_node); + current_parameter := _elna_tac_parameters(current_parameter, new_symbol_table); + _elna_tac_instruction_set_next(first_instruction, current_parameter); + + body := _procedure_declaration_get_body(parser_node); + instruction := _elna_tac_statements(body, new_symbol_table); + _elna_tac_instruction_set_next(first_instruction, instruction); + + (* Write the epilogue. *) + instruction := _elna_tac_instruction_create(ElnaTacOperator.ret); + _elna_tac_instruction_set_next(first_instruction, instruction); + + _elna_tac_declaration_set_body(result, first_instruction); + + return result +end; + +proc _elna_parser_procedures(); +var + parser_node: Word; + result: Word; + current_declaration: Word; + token_kind: Word; +begin + result := 0; + + .elna_parser_procedures_loop; + _skip_empty_lines(); + _elna_lexer_read_token(@token_kind); + + if token_kind = ElnaLexerKind._proc then + parser_node := _elna_parser_procedure_declaration(); + if result = 0 then + result := parser_node + else + _declaration_set_next(current_declaration, parser_node) + end; + current_declaration := parser_node; + + (* Skip semicolon. *) + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + goto elna_parser_procedures_loop + end; + return result +end; + +proc _elna_tac_procedures(parser_node: Word); +var + result: Word; + current_procedure: Word; + first_procedure: Word; +begin + first_procedure := 0; + + .elna_tac_procedures_loop; + if parser_node = 0 then + goto elna_tac_procedures_end + end; + result := _elna_tac_procedure_declaration(parser_node); + if first_procedure = 0 then + first_procedure := result + else + _elna_tac_declaration_set_next(current_procedure, result) + end; + current_procedure := result; + + parser_node := _declaration_get_next(parser_node); + goto elna_tac_procedures_loop; + + .elna_tac_procedures_end; + return first_procedure +end; + +(** + * Skips comments. + *) +proc _skip_empty_lines(); +var + token_kind: Word; +begin + .skip_empty_lines_rerun; + + _elna_lexer_read_token(@token_kind); + + if token_kind = ElnaLexerKind.comment then + _elna_lexer_skip_token(); + goto skip_empty_lines_rerun + end +end; + +proc _elna_parser_type_declaration(); +var + token_kind: Word; + type_name: Word; + name_length: Word; + parser_node: Word; + result: Word; + declaration_size: Word; +begin + _elna_lexer_read_token(@token_kind); + type_name := _elna_lexer_global_get_start(); + name_length := _elna_lexer_global_get_end() - type_name; + + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + parser_node := _elna_parser_type_expression(); + declaration_size := _type_declaration_size(); + result := _allocate(declaration_size); + + _node_set_kind(result, NodeKind.type_declaration); + _declaration_set_next(result, 0); + _declaration_set_name(result, type_name); + _declaration_set_length(result, name_length); + _type_declaration_set__type(result, parser_node); + + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + return result +end; + +proc _elna_name_type_declaration(parser_node: Word); +var + type_name: Word; + name_length: Word; + type_info: Word; +begin + type_name := _declaration_get_name(parser_node); + name_length := _declaration_get_length(parser_node); + + parser_node := _type_declaration_get__type(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 _elna_parser_type_part(); +var + token_kind: Word; + parser_node: Word; + result: Word; + current_declaration: Word; +begin + result := 0; + _skip_empty_lines(); + _elna_lexer_read_token(@token_kind); + + if token_kind <> ElnaLexerKind._type then + goto elna_parser_type_part_end + end; + _elna_lexer_skip_token(); + + .elna_parser_type_part_loop; + _skip_empty_lines(); + + _elna_lexer_read_token(@token_kind); + if token_kind = ElnaLexerKind.identifier then + parser_node := _elna_parser_type_declaration(); + + if result = 0 then + result := parser_node + else + _declaration_set_next(current_declaration, parser_node) + end; + current_declaration := parser_node; + goto elna_parser_type_part_loop + end; + + .elna_parser_type_part_end; + return result +end; + +proc _elna_parser_variable_declaration(); +var + token_kind: Word; + name: Word; + name_length: Word; + variable_type: Word; + result: Word; + declaration_size: Word; +begin + _elna_lexer_read_token(@token_kind); + + name := _elna_lexer_global_get_start(); + name_length := _elna_lexer_global_get_end() - name; + + (* Skip the variable name and colon with the type. *) + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + variable_type := _elna_parser_type_expression(); + + declaration_size := _variable_declaration_size(); + result := _allocate(declaration_size); + + _node_set_kind(result, NodeKind.variable_declaration); + _declaration_set_next(result, 0); + _declaration_set_name(result, name); + _declaration_set_length(result, name_length); + _variable_declaration_set__type(result, variable_type); + + return result +end; + +proc _elna_tac_variable_declaration(parser_tree: Word); +var + name: Word; + name_length: Word; + variable_type: Word; + result: Word; + result_size: Word; +begin + result_size := _elna_tac_declaration_size(); + result := _allocate(result_size); + + _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_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 _string_compare("Array", 5, name, name_length) then + (* Else we assume this is a zeroed 4096 bytes big array. *) + _elna_tac_declaration_set_body(result, 4096) + else + _elna_tac_declaration_set_body(result, 4) + end; + return result +end; + +proc _elna_tac_type_field(name_pointer: Word, name_length: Word, field_pointer: Word, field_offset: Word); +var + result_size: Word; + first_result: Word; + second_result: Word; + new_name: Word; + new_length: Word; + field_length: Word; + instruction: Word; + name_target: Word; + next_instruction: Word; +begin + result_size := _elna_tac_declaration_size(); + field_length := field_pointer + 4; + field_length := field_length^; + new_length := field_length + name_length; + new_length := new_length + 5; + + first_result := _allocate(result_size); + _elna_tac_declaration_set_next(first_result, 0); + + new_name := _allocate(new_length); + + name_target := new_name; + _memcpy(name_target, name_pointer, name_length); + name_target := name_target + name_length; + _memcpy(name_target, "_get_", 5); + name_target := name_target + 5; + _memcpy(name_target, field_pointer^, field_length); + + _elna_tac_declaration_set_name(first_result, new_name); + _elna_tac_declaration_set_length(first_result, new_length); + + instruction := _elna_tac_add_immediate(ElnaTacRegister.a0, ElnaTacRegister.a0, field_offset, 0); + next_instruction := _elna_tac_load_word(ElnaTacRegister.a0, ElnaTacRegister.a0, 0); + _elna_tac_instruction_set_next(instruction, next_instruction); + _elna_tac_declaration_set_body(first_result, instruction); + + second_result := _allocate(result_size); + _elna_tac_declaration_set_next(second_result, 0); + + new_name := _allocate(new_length); + + name_target := new_name; + _memcpy(name_target, name_pointer, name_length); + name_target := name_target + name_length; + _memcpy(name_target, "_set_", 5); + name_target := name_target + 5; + _memcpy(name_target, field_pointer^, field_length); + + _elna_tac_declaration_set_name(second_result, new_name); + _elna_tac_declaration_set_length(second_result, new_length); + + instruction := _elna_tac_add_immediate(ElnaTacRegister.a0, ElnaTacRegister.a0, field_offset, 0); + next_instruction := _elna_tac_store_word(ElnaTacRegister.a1, ElnaTacRegister.a0, 0); + _elna_tac_instruction_set_next(instruction, next_instruction); + _elna_tac_declaration_set_body(second_result, instruction); + + _elna_tac_declaration_set_next(first_result, second_result); + + return first_result +end; + +proc _elna_tac_type_record(name_pointer: Word, name_length: Word, type_representation: Word, current_result: Word); +var + result_size: Word; + first_result: Word; + result: Word; + type_size: Word; + new_name: Word; + new_length: Word; + instruction: Word; + field_count: Word; + field_offset: Word; + field_pointer: Word; +begin + result_size := _elna_tac_declaration_size(); + first_result := _allocate(result_size); + result := 0; + + (* Debug. Error stream output. + _syscall(2, name_pointer, name_length, 0, 0, 0, 64); *) + + type_size := _type_get_size(type_representation); + new_length := name_length + 5; + new_name := _allocate(new_length); + + _memcpy(new_name, name_pointer, name_length); + _memcpy(new_name + name_length, "_size", 5); + + _elna_tac_declaration_set_name(first_result, new_name); + _elna_tac_declaration_set_length(first_result, new_length); + + instruction := _elna_tac_load_immediate(ElnaTacRegister.a0, type_size, 0); + _elna_tac_declaration_set_body(first_result, instruction); + + field_count := _record_type_get_length(type_representation); + field_pointer := _record_type_get_members(type_representation); + field_offset := 0; + current_result^ := first_result; + + .elna_tac_type_record_fields; + if field_count > 0 then + result := _elna_tac_type_field(name_pointer, name_length, field_pointer, field_offset); + + _elna_tac_declaration_set_next(current_result^, result); + current_result^ := _elna_tac_declaration_get_next(result); + + field_offset := field_offset + 4; + field_count := field_count - 1; + field_pointer := field_pointer + 12; + goto elna_tac_type_record_fields + end; + + return first_result +end; + +proc _elna_tac_type_part(parser_node: Word); +var + name_pointer: Word; + name_length: Word; + result: Word; + first_result: Word; + symbol: Word; + info_type: Word; + type_kind: Word; + current_result: Word; + out_result: Word; +begin + first_result := 0; + + .elna_tac_type_part_loop; + if parser_node = 0 then + goto elna_tac_type_part_end + end; + + name_pointer := _declaration_get_name(parser_node); + name_length := _declaration_get_length(parser_node); + symbol := _symbol_table_lookup(@symbol_table_global, name_pointer, name_length); + + info_type := _type_info_get_type(symbol); + type_kind := _type_get_kind(info_type); + + if type_kind = TypeKind._record then + result := _elna_tac_type_record(name_pointer, name_length, info_type, @out_result) + else + result := 0; + out_result := 0 + end; + if first_result = 0 then + first_result := result; + current_result := out_result + elsif result <> 0 then + _elna_tac_declaration_set_next(current_result, result); + current_result := out_result + end; + parser_node := _declaration_get_next(parser_node); + goto elna_tac_type_part_loop; + + .elna_tac_type_part_end; + return first_result +end; + +proc _elna_parser_var_part(); +var + result: Word; + token_kind: Word; + variable_node: Word; + current_declaration: Word; +begin + result := 0; + _elna_lexer_read_token(@token_kind); + + if token_kind <> ElnaLexerKind._var then + goto elna_parser_var_part_end + end; + (* Skip "var". *) + _elna_lexer_skip_token(); + + .elna_parser_var_part_loop; + _skip_empty_lines(); + _elna_lexer_read_token(@token_kind); + + if token_kind = ElnaLexerKind.identifier then + variable_node := _elna_parser_variable_declaration(); + + (* Skip semicolon. *) + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + if result = 0 then + result := variable_node + else + _declaration_set_next(current_declaration, variable_node) + end; + current_declaration := variable_node; + goto elna_parser_var_part_loop + end; + + .elna_parser_var_part_end; + return result +end; + +proc _elna_tac_var_part(parser_node: Word); +var + node: Word; + current_variable: Word; + first_variable: Word; +begin + first_variable := 0; + if parser_node = 0 then + goto elna_tac_var_part_end + end; + + .elna_tac_var_part_loop; + node := _elna_tac_variable_declaration(parser_node); + if first_variable = 0 then + first_variable := node + else + _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 elna_tac_var_part_loop + end; + + .elna_tac_var_part_end; + return first_variable +end; + +proc _elna_parser_module_declaration(); +var + parser_node: Word; + declaration_size: Word; + result: Word; +begin + declaration_size := _module_declaration_size(); + result := _allocate(declaration_size); + + _node_set_kind(result, NodeKind.module_declaration); + + parser_node := _elna_parser_type_part(); + _module_declaration_set_types(result, parser_node); + + parser_node := _elna_parser_var_part(); + _module_declaration_set_globals(result, parser_node); + + parser_node := _elna_parser_procedures(); + _module_declaration_set_procedures(result, parser_node); + + return result +end; + +(** + * Process the source code and print the generated code. + *) +proc _elna_tac_module_declaration(parser_node: Word); +var + data_part: Word; + code_part: Word; + type_part: Word; + current_declaration: Word; + next_declaration: Word; +begin + type_part := _module_declaration_get_types(parser_node); + type_part := _elna_tac_type_part(type_part); + + data_part := _module_declaration_get_globals(parser_node); + data_part := _elna_tac_var_part(data_part); + + code_part := _module_declaration_get_procedures(parser_node); + code_part := _elna_tac_procedures(code_part); + + current_declaration := code_part; + + .elna_tac_module_declaration_types; + next_declaration := _elna_tac_declaration_get_next(current_declaration); + if next_declaration <> 0 then + current_declaration := next_declaration; + + goto elna_tac_module_declaration_types + end; + _elna_tac_declaration_set_next(current_declaration, type_part); + + return _elna_tac_module_create(data_part, code_part) +end; + +proc _elna_name_procedure_declaration(parser_node: Word); +var + name_pointer: Word; + name_length: Word; + new_symbol_table: Word; + parameter_counter: Word; + symbol_info: Word; + current_parameter: Word; +begin + new_symbol_table := _symbol_table_create(); + symbol_info := _procedure_info_create(new_symbol_table); + + name_pointer := _declaration_get_name(parser_node); + name_length := _declaration_get_length(parser_node); + + current_parameter := _procedure_declaration_get_parameters(parser_node); + parameter_counter := 0; + .elna_name_procedure_declaration_parameter; + if current_parameter <> 0 then + _elna_name_procedure_parameter(current_parameter, parameter_counter, new_symbol_table); + parameter_counter := parameter_counter + 1; + + current_parameter := _declaration_get_next(current_parameter); + goto elna_name_procedure_declaration_parameter + end; + current_parameter := _procedure_declaration_get_temporaries(parser_node); + _elna_name_procedure_temporaries(current_parameter, new_symbol_table); + + _symbol_table_enter(@symbol_table_global, name_pointer, name_length, symbol_info) +end; + +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); + .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 + _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; + +proc _compile(); +var + parser_node: Word; + tac: Word; +begin + parser_node := _elna_parser_module_declaration(); + _elna_name_module_declaration(parser_node); + _elna_type_module_declaration(parser_node); + tac := _elna_tac_module_declaration(parser_node); + _elna_writer_module(tac) +end; + +(** + * Terminates the program. a0 contains the return code. + * + * Parameters: + * a0 - Status code. + *) +proc _exit(status: Word); +begin + _syscall(status, 0, 0, 0, 0, 0, 93) +end; + +(** + * Looks for a symbol in the given symbol table. + * + * Parameters: + * symbol_table - Symbol table. + * symbol_name - Symbol name pointer. + * name_length - Symbol name length. + * + * Returns the symbol pointer or 0 in a0. + *) +proc _symbol_table_lookup(symbol_table: Word, symbol_name: Word, name_length: Word); +var + result: Word; + symbol_table_length: Word; + current_name: Word; + current_length: Word; +begin + result := 0; + + (* The first word in the symbol table is its length, get it. *) + symbol_table_length := symbol_table^; + + (* Go to the first symbol position. *) + symbol_table := symbol_table + 4; + + .symbol_table_lookup_loop; + if symbol_table_length = 0 then + goto symbol_table_lookup_end + end; + + (* Symbol name pointer and length. *) + current_name := symbol_table^; + current_length := symbol_table + 4; + current_length := current_length^; + + (* If lengths don't match, exit and return nil. *) + if name_length <> current_length then + goto symbol_table_lookup_repeat + end; + (* If names don't match, exit and return nil. *) + if _memcmp(symbol_name, current_name, name_length) then + goto symbol_table_lookup_repeat + end; + (* Otherwise, the symbol is found. *) + result := symbol_table + 8; + result := result^; + goto symbol_table_lookup_end; + + .symbol_table_lookup_repeat; + symbol_table := symbol_table + 12; + symbol_table_length := symbol_table_length - 1; + goto symbol_table_lookup_loop; + + .symbol_table_lookup_end; + return result +end; + +(** + * Create a new local symbol table in the symbol memory region after the last + * known symbol table. + *) +proc _symbol_table_create(); +var + new_symbol_table: Word; + table_length: Word; + current_table: Word; +begin + new_symbol_table := symbol_table_store; + + .symbol_table_create_loop; + table_length := new_symbol_table^; + + if table_length <> 0 then + table_length := table_length * 12; + table_length := table_length + 4; + new_symbol_table := new_symbol_table + table_length; + goto symbol_table_create_loop + end; + + return new_symbol_table +end; + +(** + * Inserts a symbol into the table. + * + * Parameters: + * symbol_table - Symbol table. + * symbol_name - Symbol name pointer. + * name_length - Symbol name length. + * symbol - Symbol pointer. + *) +proc _symbol_table_enter(symbol_table: Word, symbol_name: Word, name_length: Word, symbol: Word); +var + table_length: Word; + symbol_pointer: Word; +begin + (* The first word in the symbol table is its length, get it. *) + table_length := symbol_table^; + + (* Calculate the offset for the new symbol. *) + symbol_pointer := table_length * 12; + symbol_pointer := symbol_pointer + 4; + symbol_pointer := symbol_table + symbol_pointer; + + symbol_pointer^ := symbol_name; + symbol_pointer := symbol_pointer + 4; + symbol_pointer^ := name_length; + symbol_pointer := symbol_pointer + 4; + symbol_pointer^ := symbol; + + (* Increment the symbol table length. *) + table_length := table_length + 1; + symbol_table^ := table_length +end; + +proc _symbol_table_build(); +var + current_info: Word; + current_type: Word; +begin + (* Set the table length to 0. *) + symbol_table_global := 0; + + current_type := _allocate(8); + _type_set_kind(current_type, TypeKind.primitive); + _type_set_size(current_type, 4); + + (* Enter built-in symbols. *) + current_info := _type_info_create(current_type); + _symbol_table_enter(@symbol_table_global, "Word", 4, current_info); + + current_info := _type_info_create(current_type); + _symbol_table_enter(@symbol_table_global, "Array", 5, current_info) +end; + +(** + * Assigns some value to at array index. + * + * Parameters: + * array - Array pointer. + * index - Index (word offset into the array). + * data - Data to assign. + *) +proc _assign_at(array: Word, index: Word, data: Word); +var + target: Word; +begin + target := index - 1; + target := target * 4; + target := array + target; + + target^ := data +end; + +proc _get_at(array: Word, index: Word); +var + target: Word; +begin + target := index - 1; + target := target * 4; + target := array + target; + + return target^ +end; + +(** + * Initializes the array with character classes. + *) +proc _elna_lexer_classifications(); +var + code: Word; +begin + _assign_at(@classification, 1, ElnaLexerClass.eof); + _assign_at(@classification, 2, ElnaLexerClass.invalid); + _assign_at(@classification, 3, ElnaLexerClass.invalid); + _assign_at(@classification, 4, ElnaLexerClass.invalid); + _assign_at(@classification, 5, ElnaLexerClass.invalid); + _assign_at(@classification, 6, ElnaLexerClass.invalid); + _assign_at(@classification, 7, ElnaLexerClass.invalid); + _assign_at(@classification, 8, ElnaLexerClass.invalid); + _assign_at(@classification, 9, ElnaLexerClass.invalid); + _assign_at(@classification, 10, ElnaLexerClass.space); + _assign_at(@classification, 11, ElnaLexerClass.space); + _assign_at(@classification, 12, ElnaLexerClass.invalid); + _assign_at(@classification, 13, ElnaLexerClass.invalid); + _assign_at(@classification, 14, ElnaLexerClass.space); + _assign_at(@classification, 15, ElnaLexerClass.invalid); + _assign_at(@classification, 16, ElnaLexerClass.invalid); + _assign_at(@classification, 17, ElnaLexerClass.invalid); + _assign_at(@classification, 18, ElnaLexerClass.invalid); + _assign_at(@classification, 19, ElnaLexerClass.invalid); + _assign_at(@classification, 20, ElnaLexerClass.invalid); + _assign_at(@classification, 21, ElnaLexerClass.invalid); + _assign_at(@classification, 22, ElnaLexerClass.invalid); + _assign_at(@classification, 23, ElnaLexerClass.invalid); + _assign_at(@classification, 24, ElnaLexerClass.invalid); + _assign_at(@classification, 25, ElnaLexerClass.invalid); + _assign_at(@classification, 26, ElnaLexerClass.invalid); + _assign_at(@classification, 27, ElnaLexerClass.invalid); + _assign_at(@classification, 28, ElnaLexerClass.invalid); + _assign_at(@classification, 29, ElnaLexerClass.invalid); + _assign_at(@classification, 30, ElnaLexerClass.invalid); + _assign_at(@classification, 31, ElnaLexerClass.invalid); + _assign_at(@classification, 32, ElnaLexerClass.invalid); + _assign_at(@classification, 33, ElnaLexerClass.space); + _assign_at(@classification, 34, ElnaLexerClass.single); + _assign_at(@classification, 35, ElnaLexerClass.double_quote); + _assign_at(@classification, 36, ElnaLexerClass.other); + _assign_at(@classification, 37, ElnaLexerClass.other); + _assign_at(@classification, 38, ElnaLexerClass.single); + _assign_at(@classification, 39, ElnaLexerClass.single); + _assign_at(@classification, 40, ElnaLexerClass.single_quote); + _assign_at(@classification, 41, ElnaLexerClass.left_paren); + _assign_at(@classification, 42, ElnaLexerClass.right_paren); + _assign_at(@classification, 43, ElnaLexerClass.asterisk); + _assign_at(@classification, 44, ElnaLexerClass.single); + _assign_at(@classification, 45, ElnaLexerClass.single); + _assign_at(@classification, 46, ElnaLexerClass.minus); + _assign_at(@classification, 47, ElnaLexerClass.dot); + _assign_at(@classification, 48, ElnaLexerClass.single); + _assign_at(@classification, 49, ElnaLexerClass.zero); + _assign_at(@classification, 50, ElnaLexerClass.digit); + _assign_at(@classification, 51, ElnaLexerClass.digit); + _assign_at(@classification, 52, ElnaLexerClass.digit); + _assign_at(@classification, 53, ElnaLexerClass.digit); + _assign_at(@classification, 54, ElnaLexerClass.digit); + _assign_at(@classification, 55, ElnaLexerClass.digit); + _assign_at(@classification, 56, ElnaLexerClass.digit); + _assign_at(@classification, 57, ElnaLexerClass.digit); + _assign_at(@classification, 58, ElnaLexerClass.digit); + _assign_at(@classification, 59, ElnaLexerClass.colon); + _assign_at(@classification, 60, ElnaLexerClass.single); + _assign_at(@classification, 61, ElnaLexerClass.less); + _assign_at(@classification, 62, ElnaLexerClass.equals); + _assign_at(@classification, 63, ElnaLexerClass.greater); + _assign_at(@classification, 64, ElnaLexerClass.other); + _assign_at(@classification, 65, ElnaLexerClass.single); + _assign_at(@classification, 66, ElnaLexerClass.alpha); + _assign_at(@classification, 67, ElnaLexerClass.alpha); + _assign_at(@classification, 68, ElnaLexerClass.alpha); + _assign_at(@classification, 69, ElnaLexerClass.alpha); + _assign_at(@classification, 70, ElnaLexerClass.alpha); + _assign_at(@classification, 71, ElnaLexerClass.alpha); + _assign_at(@classification, 72, ElnaLexerClass.alpha); + _assign_at(@classification, 73, ElnaLexerClass.alpha); + _assign_at(@classification, 74, ElnaLexerClass.alpha); + _assign_at(@classification, 75, ElnaLexerClass.alpha); + _assign_at(@classification, 76, ElnaLexerClass.alpha); + _assign_at(@classification, 77, ElnaLexerClass.alpha); + _assign_at(@classification, 78, ElnaLexerClass.alpha); + _assign_at(@classification, 79, ElnaLexerClass.alpha); + _assign_at(@classification, 80, ElnaLexerClass.alpha); + _assign_at(@classification, 81, ElnaLexerClass.alpha); + _assign_at(@classification, 82, ElnaLexerClass.alpha); + _assign_at(@classification, 83, ElnaLexerClass.alpha); + _assign_at(@classification, 84, ElnaLexerClass.alpha); + _assign_at(@classification, 85, ElnaLexerClass.alpha); + _assign_at(@classification, 86, ElnaLexerClass.alpha); + _assign_at(@classification, 87, ElnaLexerClass.alpha); + _assign_at(@classification, 88, ElnaLexerClass.alpha); + _assign_at(@classification, 89, ElnaLexerClass.alpha); + _assign_at(@classification, 90, ElnaLexerClass.alpha); + _assign_at(@classification, 91, ElnaLexerClass.alpha); + _assign_at(@classification, 92, ElnaLexerClass.single); + _assign_at(@classification, 93, ElnaLexerClass.backslash); + _assign_at(@classification, 94, ElnaLexerClass.single); + _assign_at(@classification, 95, ElnaLexerClass.single); + _assign_at(@classification, 96, ElnaLexerClass.alpha); + _assign_at(@classification, 97, ElnaLexerClass.other); + _assign_at(@classification, 98, ElnaLexerClass.hex); + _assign_at(@classification, 99, ElnaLexerClass.hex); + _assign_at(@classification, 100, ElnaLexerClass.hex); + _assign_at(@classification, 101, ElnaLexerClass.hex); + _assign_at(@classification, 102, ElnaLexerClass.hex); + _assign_at(@classification, 103, ElnaLexerClass.hex); + _assign_at(@classification, 104, ElnaLexerClass.alpha); + _assign_at(@classification, 105, ElnaLexerClass.alpha); + _assign_at(@classification, 106, ElnaLexerClass.alpha); + _assign_at(@classification, 107, ElnaLexerClass.alpha); + _assign_at(@classification, 108, ElnaLexerClass.alpha); + _assign_at(@classification, 109, ElnaLexerClass.alpha); + _assign_at(@classification, 110, ElnaLexerClass.alpha); + _assign_at(@classification, 111, ElnaLexerClass.alpha); + _assign_at(@classification, 112, ElnaLexerClass.alpha); + _assign_at(@classification, 113, ElnaLexerClass.alpha); + _assign_at(@classification, 114, ElnaLexerClass.alpha); + _assign_at(@classification, 115, ElnaLexerClass.alpha); + _assign_at(@classification, 116, ElnaLexerClass.alpha); + _assign_at(@classification, 117, ElnaLexerClass.alpha); + _assign_at(@classification, 118, ElnaLexerClass.alpha); + _assign_at(@classification, 119, ElnaLexerClass.alpha); + _assign_at(@classification, 120, ElnaLexerClass.alpha); + _assign_at(@classification, 121, ElnaLexerClass.x); + _assign_at(@classification, 122, ElnaLexerClass.alpha); + _assign_at(@classification, 123, ElnaLexerClass.alpha); + _assign_at(@classification, 124, ElnaLexerClass.other); + _assign_at(@classification, 125, ElnaLexerClass.single); + _assign_at(@classification, 126, ElnaLexerClass.other); + _assign_at(@classification, 127, ElnaLexerClass.single); + _assign_at(@classification, 128, ElnaLexerClass.invalid); + + code := 129; + + (* Set the remaining 129 - 256 bytes to transitionClassOther. *) + .create_classification_loop; + _assign_at(@classification, code, ElnaLexerClass.other); + code := code + 1; + + if code < 257 then + goto create_classification_loop + end +end; + +proc _elna_lexer_get_transition(current_state: Word, character_class: Word); +var + transition_table: Word; + row_position: Word; + column_position: Word; + target: Word; +begin + (* Each state is 8 bytes long (2 words: action and next state). + There are 22 character classes, so a transition row 8 * 22 = 176 bytes long. *) + row_position := current_state - 1; + row_position := row_position * 176; + + column_position := character_class - 1; + column_position := column_position * 8; + + target := _elna_lexer_get_transition_table(); + target := target + row_position; + + return target + column_position +end; + +(** + * Parameters: + * current_state - First index into transitions table. + * character_class - Second index into transitions table. + * action - Action to assign. + * next_state - Next state to assign. + *) +proc _elna_lexer_set_transition(current_state: Word, character_class: Word, action: Word, next_state: Word); +var + transition: Word; +begin + transition := _elna_lexer_get_transition(current_state, character_class); + + _elna_lexer_transition_set_action(transition, action); + _elna_lexer_transition_set_state(transition, next_state) +end; + +(* Sets same action and state transition for all character classes in one transition row. *) + +(** + * Parameters: + * current_state - Current state (Transition state enumeration). + * default_action - Default action (Callback). + * next_state - Next state (Transition state enumeration). + *) +proc _elna_lexer_default_transition(current_state: Word, default_action: Word, next_state: Word); +begin + _elna_lexer_set_transition(current_state, ElnaLexerClass.invalid, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.digit, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.alpha, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.space, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.colon, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.equals, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.left_paren, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.right_paren, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.asterisk, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.backslash, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.single, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.hex, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.zero, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.x, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.eof, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.dot, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.minus, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.single_quote, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.double_quote, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.greater, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.less, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.other, default_action, next_state) +end; + +(** + * The transition table describes transitions from one state to another, given + * a symbol (character class). + * + * The table has m rows and n columns, where m is the amount of states and n is + * the amount of classes. So given the current state and a classified character + * the table can be used to look up the next state. + *) +proc _elna_lexer_transitions(); +begin + (* Start state. *) + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.digit, ElnaLexerAction.accumulate, ElnaLexerState.decimal); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.alpha, ElnaLexerAction.accumulate, ElnaLexerState.identifier); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.space, ElnaLexerAction.skip, ElnaLexerState.start); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.colon, ElnaLexerAction.accumulate, ElnaLexerState.colon); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.equals, ElnaLexerAction.single, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.left_paren, ElnaLexerAction.accumulate, ElnaLexerState.left_paren); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.right_paren, ElnaLexerAction.single, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.asterisk, ElnaLexerAction.single, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.backslash, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.single, ElnaLexerAction.single, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.hex, ElnaLexerAction.accumulate, ElnaLexerState.identifier); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.zero, ElnaLexerAction.accumulate, ElnaLexerState.leading_zero); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.x, ElnaLexerAction.accumulate, ElnaLexerState.identifier); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.eof, ElnaLexerAction.eof, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.dot, ElnaLexerAction.single, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.minus, ElnaLexerAction.accumulate, ElnaLexerState.minus); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.single_quote, ElnaLexerAction.accumulate, ElnaLexerState.character); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.double_quote, ElnaLexerAction.accumulate, ElnaLexerState.string); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.greater, ElnaLexerAction.accumulate, ElnaLexerState.greater); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.less, ElnaLexerAction.accumulate, ElnaLexerState.less); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.other, ElnaLexerAction.none, ElnaLexerState.finish); + + (* Colon state. *) + _elna_lexer_default_transition(ElnaLexerState.colon, ElnaLexerAction.finalize, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.colon, ElnaLexerClass.equals, ElnaLexerAction.composite, ElnaLexerState.finish); + + (* Identifier state. *) + _elna_lexer_default_transition(ElnaLexerState.identifier, ElnaLexerAction.key_id, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.identifier, ElnaLexerClass.digit, ElnaLexerAction.accumulate, ElnaLexerState.identifier); + _elna_lexer_set_transition(ElnaLexerState.identifier, ElnaLexerClass.alpha, ElnaLexerAction.accumulate, ElnaLexerState.identifier); + _elna_lexer_set_transition(ElnaLexerState.identifier, ElnaLexerClass.hex, ElnaLexerAction.accumulate, ElnaLexerState.identifier); + _elna_lexer_set_transition(ElnaLexerState.identifier, ElnaLexerClass.zero, ElnaLexerAction.accumulate, ElnaLexerState.identifier); + _elna_lexer_set_transition(ElnaLexerState.identifier, ElnaLexerClass.x, ElnaLexerAction.accumulate, ElnaLexerState.identifier); + + (* Decimal state. *) + _elna_lexer_default_transition(ElnaLexerState.decimal, ElnaLexerAction.integer, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.decimal, ElnaLexerClass.digit, ElnaLexerAction.accumulate, ElnaLexerState.decimal); + _elna_lexer_set_transition(ElnaLexerState.decimal, ElnaLexerClass.alpha, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.decimal, ElnaLexerClass.hex, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.decimal, ElnaLexerClass.zero, ElnaLexerAction.accumulate, ElnaLexerState.decimal); + _elna_lexer_set_transition(ElnaLexerState.decimal, ElnaLexerClass.x, ElnaLexerAction.none, ElnaLexerState.finish); + + (* Leading zero. *) + _elna_lexer_default_transition(ElnaLexerState.leading_zero, ElnaLexerAction.integer, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.leading_zero, ElnaLexerClass.digit, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.leading_zero, ElnaLexerClass.alpha, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.leading_zero, ElnaLexerClass.hex, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.leading_zero, ElnaLexerClass.zero, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.leading_zero, ElnaLexerClass.x, ElnaLexerAction.none, ElnaLexerState.dot); + + (* Greater state. *) + _elna_lexer_default_transition(ElnaLexerState.greater, ElnaLexerAction.finalize, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.greater, ElnaLexerClass.equals, ElnaLexerAction.composite, ElnaLexerState.finish); + + (* Minus state. *) + _elna_lexer_default_transition(ElnaLexerState.minus, ElnaLexerAction.finalize, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.minus, ElnaLexerClass.greater, ElnaLexerAction.composite, ElnaLexerState.finish); + + (* Left paren state. *) + _elna_lexer_default_transition(ElnaLexerState.left_paren, ElnaLexerAction.finalize, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.left_paren, ElnaLexerClass.asterisk, ElnaLexerAction.accumulate, ElnaLexerState.comment); + + (* Less state. *) + _elna_lexer_default_transition(ElnaLexerState.less, ElnaLexerAction.finalize, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.less, ElnaLexerClass.equals, ElnaLexerAction.composite, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.less, ElnaLexerClass.greater, ElnaLexerAction.composite, ElnaLexerState.finish); + + (* Hexadecimal after 0x. *) + _elna_lexer_default_transition(ElnaLexerState.dot, ElnaLexerAction.finalize, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.dot, ElnaLexerClass.dot, ElnaLexerAction.composite, ElnaLexerState.finish); + + (* Comment. *) + _elna_lexer_default_transition(ElnaLexerState.comment, ElnaLexerAction.accumulate, ElnaLexerState.comment); + _elna_lexer_set_transition(ElnaLexerState.comment, ElnaLexerClass.asterisk, ElnaLexerAction.accumulate, ElnaLexerState.closing_comment); + _elna_lexer_set_transition(ElnaLexerState.comment, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish); + + (* Closing comment. *) + _elna_lexer_default_transition(ElnaLexerState.closing_comment, ElnaLexerAction.accumulate, ElnaLexerState.comment); + _elna_lexer_set_transition(ElnaLexerState.closing_comment, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.closing_comment, ElnaLexerClass.right_paren, ElnaLexerAction.delimited, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.closing_comment, ElnaLexerClass.asterisk, ElnaLexerAction.accumulate, ElnaLexerState.closing_comment); + _elna_lexer_set_transition(ElnaLexerState.closing_comment, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish); + + (* Character. *) + _elna_lexer_default_transition(ElnaLexerState.character, ElnaLexerAction.accumulate, ElnaLexerState.character); + _elna_lexer_set_transition(ElnaLexerState.character, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.character, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.character, ElnaLexerClass.single_quote, ElnaLexerAction.delimited, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.character, ElnaLexerClass.backslash, ElnaLexerAction.accumulate, ElnaLexerState.character_escape); + + (* Escape sequence in a character. *) + _elna_lexer_default_transition(ElnaLexerState.character_escape, ElnaLexerAction.accumulate, ElnaLexerState.character); + _elna_lexer_set_transition(ElnaLexerState.character_escape, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.character_escape, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish); + + (* String. *) + _elna_lexer_default_transition(ElnaLexerState.string, ElnaLexerAction.accumulate, ElnaLexerState.string); + _elna_lexer_set_transition(ElnaLexerState.string, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.string, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.string, ElnaLexerClass.double_quote, ElnaLexerAction.delimited, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.string, ElnaLexerClass.backslash, ElnaLexerAction.accumulate, ElnaLexerState.string_escape); + + (* Escape sequence in a string. *) + _elna_lexer_default_transition(ElnaLexerState.string_escape, ElnaLexerAction.accumulate, ElnaLexerState.string); + _elna_lexer_set_transition(ElnaLexerState.string_escape, ElnaLexerClass.invalid, ElnaLexerAction.none, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.string_escape, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish) +end; + +(** + * Transition table is saved after character classification table. + * Each character entry is 1 word long and there are 256 characters. + * 1024 = 256 * 4 + *) +proc _elna_lexer_get_transition_table(); + return @classification + 1024 +end; + +(** + * Lexer state is saved after the transition tables. + * Each transition table entry is 8 bytes long. The table has 16 rows (transition states) + * and 22 columns (character classes), so 2992 = 8 * 17 * 22. + *) +proc _elna_lexer_global_state(); +var + result: Word; +begin + result := _elna_lexer_get_transition_table(); + return result + 2992 +end; + +(** + * Gets pointer to the token start. + *) +proc _elna_lexer_global_get_start(); +var + target: Word; +begin + target := _elna_lexer_global_state() + 4; + return target^ +end; + +(** + * Sets pointer to the token start. + *) +proc _elna_lexer_global_set_start(new_start: Word); +var + target: Word; +begin + target := _elna_lexer_global_state() + 4; + target^ := new_start +end; + +(** + * Gets pointer to the token end. + *) +proc _elna_lexer_global_get_end(); +var + target: Word; +begin + target := _elna_lexer_global_state() + 8; + return target^ +end; + +(** + * Sets pointer to the token end. + *) +proc _elna_lexer_global_set_end(new_start: Word); +var + target: Word; +begin + target := _elna_lexer_global_state() + 8; + target^ := new_start +end; + +proc _elna_lexer_transition_get_action(this: Word); + return this^ +end; + +proc _elna_lexer_transition_set_action(this: Word, value: Word); +begin + this^ := value +end; + +proc _elna_lexer_transition_get_state(this: Word); +begin + this := this + 4; + return this^ +end; + +proc _elna_lexer_transition_set_state(this: Word, value: Word); +begin + this := this + 4; + this^ := value +end; + +(** + * Resets the lexer state for reading the next token. + *) +proc _elna_lexer_reset(); +var + state: Word; +begin + (* Transition start state is 1. *) + state := _elna_lexer_global_state(); + state^ := ElnaLexerState.start; + + state := _elna_lexer_global_get_start(); + _elna_lexer_global_set_end(state) +end; + +(** + * One time lexer initialization. + *) +proc _elna_lexer_initialize(code_pointer: Word); +begin + _elna_lexer_classifications(); + _elna_lexer_transitions(); + + _elna_lexer_global_set_start(code_pointer); + _elna_lexer_global_set_end(code_pointer) +end; + +proc _elna_lexer_next_transition(); +var + current_character: Word; + character_class: Word; + current_state: Word; +begin + current_character := _elna_lexer_global_get_end(); + current_character := _load_byte(current_character); + + character_class := _get_at(@classification, current_character + 1); + + current_state := _elna_lexer_global_state(); + current_state := current_state^; + + return _elna_lexer_get_transition(current_state, character_class) +end; + +proc _string_compare(lhs_pointer: Word, lhs_length: Word, rhs_pointer: Word, rhs_length: Word); +var + result: Word; +begin + result := 0; + + if lhs_length = rhs_length then + result := _memcmp(lhs_pointer, rhs_pointer, lhs_length); + result := result = 0 + end; + return result +end; + +proc _elna_lexer_classify_keyword(position_start: Word, position_end: Word); +var + result: Word; + token_length: Word; +begin + result := ElnaLexerKind.identifier; + token_length := position_end - position_start; + + if _string_compare(position_start, token_length, "const", 5) then + result := ElnaLexerKind._const + elsif _string_compare(position_start, token_length, "var", 3) then + result := ElnaLexerKind._var + elsif _string_compare(position_start, token_length, "proc", 4) then + result := ElnaLexerKind._proc + elsif _string_compare(position_start, token_length, "type", 4) then + result := ElnaLexerKind._type + elsif _string_compare(position_start, token_length, "begin", 5) then + result := ElnaLexerKind._begin + elsif _string_compare(position_start, token_length, "end", 3) then + result := ElnaLexerKind._end + elsif _string_compare(position_start, token_length, "return", 6) then + result := ElnaLexerKind._return + elsif _string_compare(position_start, token_length, "goto", 4) then + result := ElnaLexerKind._goto + elsif _string_compare(position_start, token_length, "if", 2) then + result := ElnaLexerKind._if + elsif _string_compare(position_start, token_length, "while", 5) then + result := ElnaLexerKind._while + elsif _string_compare(position_start, token_length, "then", 4) then + result := ElnaLexerKind._then + elsif _string_compare(position_start, token_length, "else", 4) then + result := ElnaLexerKind._else + elsif _string_compare(position_start, token_length, "elsif", 5) then + result := ElnaLexerKind._elsif + elsif _string_compare(position_start, token_length, "record", 6) then + result := ElnaLexerKind._record + elsif _string_compare(position_start, token_length, "or", 2) then + result := ElnaLexerKind._or + elsif _string_compare(position_start, token_length, "xor", 2) then + result := ElnaLexerKind._xor + end; + return result +end; + +proc _elna_lexer_classify_finalize(start_position: Word); +var + character: Word; + result: Word; +begin + result := 0; + character := _load_byte(start_position); + + if character = ':' then + result := ElnaLexerKind.colon + elsif character = '.' then + result := ElnaLexerKind.dot + elsif character = '(' then + result := ElnaLexerKind.left_paren + elsif character = '-' then + result := ElnaLexerKind.minus + elsif character = '<' then + result := ElnaLexerKind.less_than + elsif character = '>' then + result := ElnaLexerKind.greater_than + end; + return result +end; + +proc _elna_lexer_classify_single(start_position: Word); +var + character: Word; + result: Word; +begin + result := 0; + character := _load_byte(start_position); + + if character = ';' then + result := ElnaLexerKind.semicolon + elsif character = ',' then + result := ElnaLexerKind.comma + elsif character = ')' then + result := ElnaLexerKind.right_paren + elsif character = '@' then + result := ElnaLexerKind.at + elsif character = '~' then + result := ElnaLexerKind.not + elsif character = '&' then + result := ElnaLexerKind.and + elsif character = '+' then + result := ElnaLexerKind.plus + elsif character = '*' then + result := ElnaLexerKind.multiplication + elsif character = '=' then + result := ElnaLexerKind.equals + elsif character = '%' then + result := ElnaLexerKind.remainder + elsif character = '/' then + result := ElnaLexerKind.division + elsif character = '.' then + result := ElnaLexerKind.dot + elsif character = '^' then + result := ElnaLexerKind.hat + end; + return result +end; + +proc _elna_lexer_classify_composite(start_position: Word, one_before_last: Word); +var + first_character: Word; + last_character: Word; + result: Word; +begin + first_character := _load_byte(start_position); + last_character := _load_byte(one_before_last); + + if first_character = ':' then + result := ElnaLexerKind.assignment + elsif first_character = '<' then + if last_character = '=' then + result := ElnaLexerKind.less_equal + elsif last_character = '>' then + result := ElnaLexerKind.not_equal + end + elsif first_character = '>' then + if last_character = '=' then + result := ElnaLexerKind.greater_equal + end + end; + + return result +end; + +proc _elna_lexer_classify_delimited(start_position: Word, end_position: Word); +var + token_length: Word; + delimiter: Word; + result: Word; +begin + token_length := end_position - start_position; + delimiter := _load_byte(start_position); + + if delimiter = '(' then + result := ElnaLexerKind.comment + elsif delimiter = '\'' then + result := ElnaLexerKind.character + elsif delimiter = '"' then + result := ElnaLexerKind.string + end; + return result +end; + +proc _elna_lexer_classify_integer(start_position: Word, end_position: Word); + return ElnaLexerKind.integer +end; + +proc _elna_lexer_execute_action(action_to_perform: Word, kind: Word); +var + position_start: Word; + position_end: Word; + intermediate: Word; +begin + position_start := _elna_lexer_global_get_start(); + position_end := _elna_lexer_global_get_end(); + + if action_to_perform = ElnaLexerAction.none then + elsif action_to_perform = ElnaLexerAction.accumulate then + _elna_lexer_global_set_end(position_end + 1) + elsif action_to_perform = ElnaLexerAction.skip then + _elna_lexer_global_set_start(position_start + 1); + _elna_lexer_global_set_end(position_end + 1) + elsif action_to_perform = ElnaLexerAction.single then + _elna_lexer_global_set_end(position_end + 1); + + intermediate := _elna_lexer_classify_single(position_start); + kind^ := intermediate + elsif action_to_perform = ElnaLexerAction.eof then + intermediate := ElnaLexerKind.eof; + kind^ := intermediate + elsif action_to_perform = ElnaLexerAction.finalize then + intermediate := _elna_lexer_classify_finalize(position_start); + kind^ := intermediate + elsif action_to_perform = ElnaLexerAction.composite then + _elna_lexer_global_set_end(position_end + 1); + + intermediate := _elna_lexer_classify_composite(position_start, position_end); + kind^ := intermediate + elsif action_to_perform = ElnaLexerAction.key_id then + intermediate := _elna_lexer_classify_keyword(position_start, position_end); + kind^ := intermediate + elsif action_to_perform = ElnaLexerAction.integer then + intermediate := _elna_lexer_classify_integer(position_start, position_end); + kind^ := intermediate + elsif action_to_perform = ElnaLexerAction.delimited then + _elna_lexer_global_set_end(position_end + 1); + + intermediate := _elna_lexer_classify_delimited(position_start, position_end + 1); + kind^ := intermediate + end +end; + +proc _elna_lexer_execute_transition(kind: Word); +var + next_transition: Word; + next_state: Word; + global_state: Word; + action_to_perform: Word; +begin + next_transition := _elna_lexer_next_transition(); + next_state := _elna_lexer_transition_get_state(next_transition); + action_to_perform := _elna_lexer_transition_get_action(next_transition); + + global_state := _elna_lexer_global_state(); + + global_state^ := next_state; + _elna_lexer_execute_action(action_to_perform, kind); + + return next_state +end; + +proc _elna_lexer_advance_token(kind: Word); +var + result_state: Word; +begin + result_state := _elna_lexer_execute_transition(kind); + if result_state <> ElnaLexerState.finish then + _elna_lexer_advance_token(kind) + end +end; + +(** + * Reads the next token and writes its type into the address in the kind parameter. + *) +proc _elna_lexer_read_token(kind: Word); +begin + _elna_lexer_reset(); + _elna_lexer_advance_token(kind) +end; + +(** + * Advances the token stream past the last read token. + *) +proc _elna_lexer_skip_token(); +var + old_end: Word; +begin + old_end := _elna_lexer_global_get_end(); + _elna_lexer_global_set_start(old_end) +end; + +proc _initialize_global_state(); +begin + compiler_strings_position := @compiler_strings; + memory_free_pointer := _mmap(4194304); + source_code := _mmap(495616); + symbol_table_store := _mmap(495616) +end; + +(* + * Entry point. + *) +proc _start(); +var + last_read: Word; + offset: Word; +begin + _initialize_global_state(); + _elna_lexer_initialize(source_code); + _symbol_table_build(); + + (* Read the source from the standard input. *) + offset := source_code; + + .start_read; + (* Second argument is buffer size. Modifying update the source_code definition. *) + last_read := _read_file(offset, 409600); + if last_read > 0 then + offset := offset + last_read; + goto start_read + end; + _compile(); + + _exit(0) +end;