From fd9e8a36b56a90770c9beb269ca849a67d2a106b Mon Sep 17 00:00:00 2001 From: Eugen Wissner Date: Wed, 19 Nov 2025 10:25:41 +0100 Subject: [PATCH] Add jump_if_not_zero and bnez instructions --- boot/stage15/cl.elna | 17 ++++- boot/stage16/cl.elna | 177 +++++++++++++++++++++++++------------------ 2 files changed, 120 insertions(+), 74 deletions(-) diff --git a/boot/stage15/cl.elna b/boot/stage15/cl.elna index 031cec2..f2d2cab 100644 --- a/boot/stage15/cl.elna +++ b/boot/stage15/cl.elna @@ -4317,12 +4317,21 @@ var parser_node: Word; declaration_size: Word; result: Word; + token_kind: Word; begin declaration_size := _module_declaration_size(); result := _allocate(declaration_size); _node_set_kind(result, NodeKind.module_declaration); + _skip_empty_lines(); + _elna_lexer_read_token(@token_kind); + if token_kind = ElnaLexerKind._program then + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token() + end; + parser_node := _elna_parser_type_part(); _module_declaration_set_types(result, parser_node); @@ -5161,8 +5170,14 @@ begin 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 + elsif _string_compare(position_start, token_length, "xor", 3) then result := ElnaLexerKind._xor + elsif _string_compare(position_start, token_length, "program", 7) then + result := ElnaLexerKind._program + elsif _string_compare(position_start, token_length, "module", 6) then + result := ElnaLexerKind._module + elsif _string_compare(position_start, token_length, "nil", 3) then + result := ElnaLexerKind.null end; return result end; diff --git a/boot/stage16/cl.elna b/boot/stage16/cl.elna index e47e8e4..e99efbd 100644 --- a/boot/stage16/cl.elna +++ b/boot/stage16/cl.elna @@ -3,6 +3,7 @@ * 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/. *) +program; (* Stage 16 compiler. *) @@ -351,29 +352,30 @@ type ElnaTacOperator = ( get_address, add, - load_word, - store_word, - jal, - assign, - sub, - div, - rem, - mul, + load, + store, + proc_call, + copy, + subtract, + divide, + remainder, + multiply, _xor, _or, and, - slt, - sgt, - sle, - sge, - seq, - sne, - neg, - not, + less_than, + greater_than, + less_or_equal, + greater_or_equal, + equal, + not_equal, + negate, + complement, jump, - beqz, + jump_if_zero, + jump_if_not_zero, label, - ret + _return ); ElnaRtlOperator = ( li, @@ -397,8 +399,9 @@ type xori, neg, not, - jump, + j, beqz, + bnez, label, allocate_stack, ret @@ -965,6 +968,17 @@ begin elna_rtl_instruction_set_operand(rtl_instruction, number, operand_type, operand_value, operand_length) end; +proc elna_rtl_conditional_jump(tac_instruction: Word, condition: Word); +var + result: Word; +begin + result := elna_rtl_instruction_create(condition); + elna_rtl_copy_operand(tac_instruction, 1, result); + elna_rtl_copy_operand(tac_instruction, 2, result); + + return result +end; + proc elna_rtl_instruction(tac_instruction: Word, next_instruction: Word); var result: Word; @@ -1003,7 +1017,7 @@ begin end elsif instruction_kind = ElnaTacOperator.add then result := elna_rtl_binary_arithmetic(tac_instruction, next_instruction, ElnaRtlOperator.add) - elsif instruction_kind = ElnaTacOperator.load_word then + elsif instruction_kind = ElnaTacOperator.load then operand_type := _elna_tac_instruction_get_operand_type(tac_instruction, 2); if operand_type = ElnaTacOperand.stack then @@ -1024,7 +1038,7 @@ begin operand_value := _elna_tac_instruction_get_operand_value(tac_instruction, 2); elna_rtl_instruction_set_operand(result, 2, ElnaRtlOperand.offset, operand_value, 0) end - elsif instruction_kind = ElnaTacOperator.store_word then + elsif instruction_kind = ElnaTacOperator.store then operands := elna_rtl_load_operand_value(tac_instruction, 1, ElnaRtlRegister.t0); next_instruction^ := elna_rtl_instruction_create(ElnaRtlOperator.sw); result := operands; @@ -1045,16 +1059,16 @@ begin else ElnaInstructionList_set_next(operands, next_instruction^) end - elsif instruction_kind = ElnaTacOperator.jal then + elsif instruction_kind = ElnaTacOperator.proc_call then result := elna_rtl_instruction_create(ElnaRtlOperator.jal); elna_rtl_copy_operand(tac_instruction, 1, result) - elsif instruction_kind = ElnaTacOperator.sub then + elsif instruction_kind = ElnaTacOperator.subtract then result := elna_rtl_binary_arithmetic(tac_instruction, next_instruction, ElnaRtlOperator.sub) - elsif instruction_kind = ElnaTacOperator.mul then + elsif instruction_kind = ElnaTacOperator.multiply then result := elna_rtl_binary_arithmetic(tac_instruction, next_instruction, ElnaRtlOperator.mul) - elsif instruction_kind = ElnaTacOperator.div then + elsif instruction_kind = ElnaTacOperator.divide then result := elna_rtl_binary_arithmetic(tac_instruction, next_instruction, ElnaRtlOperator.div) - elsif instruction_kind = ElnaTacOperator.rem then + elsif instruction_kind = ElnaTacOperator.remainder then result := elna_rtl_binary_arithmetic(tac_instruction, next_instruction, ElnaRtlOperator.rem) elsif instruction_kind = ElnaTacOperator._xor then result := elna_rtl_binary_arithmetic(tac_instruction, next_instruction, ElnaRtlOperator._xor) @@ -1062,9 +1076,9 @@ begin result := elna_rtl_binary_arithmetic(tac_instruction, next_instruction, ElnaRtlOperator._or) elsif instruction_kind = ElnaTacOperator.and then result := elna_rtl_binary_arithmetic(tac_instruction, next_instruction, ElnaRtlOperator.and) - elsif instruction_kind = ElnaTacOperator.slt then + elsif instruction_kind = ElnaTacOperator.less_than then result := elna_rtl_binary_arithmetic(tac_instruction, next_instruction, ElnaRtlOperator.slt) - elsif instruction_kind = ElnaTacOperator.sgt then + elsif instruction_kind = ElnaTacOperator.greater_than then operands := elna_rtl_binary_operands(tac_instruction, next_instruction); result := elna_rtl_instruction_create(ElnaRtlOperator.slt); @@ -1077,7 +1091,7 @@ begin result := operands; elna_rtl_instruction_set_kind(next_instruction^, ElnaRtlOperator.slt) - elsif instruction_kind = ElnaTacOperator.sle then + elsif instruction_kind = ElnaTacOperator.less_or_equal then operands := elna_rtl_binary_operands(tac_instruction, next_instruction); intermediate_instruction := elna_rtl_instruction_create(ElnaRtlOperator.slt); @@ -1096,7 +1110,7 @@ begin result := operands; elna_rtl_instruction_set_kind(next_instruction^, ElnaRtlOperator.xori) - elsif instruction_kind = ElnaTacOperator.sge then + elsif instruction_kind = ElnaTacOperator.greater_or_equal then operands := elna_rtl_binary_operands(tac_instruction, next_instruction); intermediate_instruction := elna_rtl_instruction_create(ElnaRtlOperator.slt); @@ -1115,31 +1129,31 @@ begin result := operands; elna_rtl_instruction_set_kind(next_instruction^, ElnaRtlOperator.xori) - elsif instruction_kind = ElnaTacOperator.seq then + elsif instruction_kind = ElnaTacOperator.equal then result := elna_rtl_binary_equality(tac_instruction, ElnaRtlOperator.seqz, next_instruction) - elsif instruction_kind = ElnaTacOperator.sne then + elsif instruction_kind = ElnaTacOperator.not_equal then result := elna_rtl_binary_equality(tac_instruction, ElnaRtlOperator.snez, next_instruction) - elsif instruction_kind = ElnaTacOperator.neg then + elsif instruction_kind = ElnaTacOperator.negate then result := elna_rtl_instruction_create(ElnaRtlOperator.neg); elna_rtl_copy_operand(tac_instruction, 1, result); elna_rtl_copy_operand(tac_instruction, 2, result) - elsif instruction_kind = ElnaTacOperator.not then + elsif instruction_kind = ElnaTacOperator.complement then result := elna_rtl_instruction_create(ElnaRtlOperator.not); elna_rtl_copy_operand(tac_instruction, 1, result); elna_rtl_copy_operand(tac_instruction, 2, result) elsif instruction_kind = ElnaTacOperator.jump then - result := elna_rtl_instruction_create(ElnaRtlOperator.jump); + result := elna_rtl_instruction_create(ElnaRtlOperator.j); elna_rtl_copy_operand(tac_instruction, 1, result) - elsif instruction_kind = ElnaTacOperator.beqz then - result := elna_rtl_instruction_create(ElnaRtlOperator.beqz); - elna_rtl_copy_operand(tac_instruction, 1, result); - elna_rtl_copy_operand(tac_instruction, 2, result) - elsif instruction_kind = ElnaTacOperator.ret then + elsif instruction_kind = ElnaTacOperator.jump_if_zero then + result := elna_rtl_conditional_jump(tac_instruction, ElnaRtlOperator.beqz) + elsif instruction_kind = ElnaTacOperator.jump_if_not_zero then + result := elna_rtl_conditional_jump(tac_instruction, ElnaRtlOperator.bnez) + elsif instruction_kind = ElnaTacOperator._return then result := elna_rtl_load_operand_value(tac_instruction, 1, ElnaRtlRegister.a0) elsif instruction_kind = ElnaTacOperator.label then result := elna_rtl_instruction_create(ElnaRtlOperator.label); elna_rtl_copy_operand(tac_instruction, 1, result) - elsif instruction_kind = ElnaTacOperator.assign then + elsif instruction_kind = ElnaTacOperator.copy then operand_type := _elna_tac_instruction_get_operand_type(tac_instruction, 1); operand_value := _elna_tac_instruction_get_operand_value(tac_instruction, 1); @@ -1262,12 +1276,15 @@ begin elsif instruction_kind = ElnaRtlOperator.not then argument_count := 2; _write_s("\tnot", 4) - elsif instruction_kind = ElnaRtlOperator.jump then + elsif instruction_kind = ElnaRtlOperator.j then argument_count := 1; _write_s("\tj", 2) elsif instruction_kind = ElnaRtlOperator.beqz then argument_count := 2; _write_s("\tbeqz", 5) + elsif instruction_kind = ElnaRtlOperator.bnez then + argument_count := 2; + _write_s("\tbnez", 5) else (* ElnaRtlOperator.allocate_stack or ElnaRtlOperator.ret *) argument_count := 0 end; @@ -1800,7 +1817,7 @@ begin operand := operand_type^; if is_address then - instruction := _elna_tac_instruction_create(ElnaTacOperator.load_word); + instruction := _elna_tac_instruction_create(ElnaTacOperator.load); _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.temporary, 6, 0); _elna_tac_instruction_set_operand(instruction, 2, operand_type^, operand_value^, operand_length^); @@ -1810,7 +1827,7 @@ begin elna_instruction_list_concatenate(first_instruction, instruction) else - instruction := _elna_tac_instruction_create(ElnaTacOperator.assign); + instruction := _elna_tac_instruction_create(ElnaTacOperator.copy); _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.temporary, 6, 0); _elna_tac_instruction_set_operand(instruction, 2, operand_type^, operand_value^, operand_length^); @@ -1822,12 +1839,12 @@ begin end end; if operator = '-' then - instruction := _elna_tac_instruction_create(ElnaTacOperator.neg); + instruction := _elna_tac_instruction_create(ElnaTacOperator.negate); _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.temporary, 6, 0); _elna_tac_instruction_set_operand(instruction, 2, ElnaTacOperand.temporary, 6, 0); elna_instruction_list_concatenate(first_instruction, instruction) elsif operator = '~' then - instruction := _elna_tac_instruction_create(ElnaTacOperator.not); + instruction := _elna_tac_instruction_create(ElnaTacOperator.complement); _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.temporary, 6, 0); _elna_tac_instruction_set_operand(instruction, 2, ElnaTacOperand.temporary, 6, 0); elna_instruction_list_concatenate(first_instruction, instruction) @@ -1928,7 +1945,7 @@ begin first_instruction := _elna_tac_unary_expression(operand_node, symbol_table, @lhs_type, @lhs_value, @lhs_length); (* Save the value of the left expression on the stack. *) - instruction := _elna_tac_instruction_create(ElnaTacOperator.assign); + instruction := _elna_tac_instruction_create(ElnaTacOperator.copy); _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.stack, 72, 0); _elna_tac_instruction_set_operand(instruction, 2, lhs_type, lhs_value, lhs_length); @@ -1948,7 +1965,7 @@ begin current_instruction := elna_instruction_list_concatenate(current_instruction, instruction); (* Load the left expression from the stack; *) - instruction := _elna_tac_instruction_create(ElnaTacOperator.assign); + instruction := _elna_tac_instruction_create(ElnaTacOperator.copy); _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.temporary, 7, 0); _elna_tac_instruction_set_operand(instruction, 2, ElnaTacOperand.stack, 72, 0); @@ -1958,9 +1975,9 @@ begin if token_kind = ElnaLexerKind.plus then instruction := _elna_tac_instruction_create(ElnaTacOperator.add) elsif token_kind = ElnaLexerKind.minus then - instruction := _elna_tac_instruction_create(ElnaTacOperator.sub) + instruction := _elna_tac_instruction_create(ElnaTacOperator.subtract) elsif token_kind = ElnaLexerKind.multiplication then - instruction := _elna_tac_instruction_create(ElnaTacOperator.mul) + instruction := _elna_tac_instruction_create(ElnaTacOperator.multiply) elsif token_kind = ElnaLexerKind.and then instruction := _elna_tac_instruction_create(ElnaTacOperator.and) elsif token_kind = ElnaLexerKind._or then @@ -1968,21 +1985,21 @@ begin elsif token_kind = ElnaLexerKind._xor then instruction := _elna_tac_instruction_create(ElnaTacOperator._xor) elsif token_kind = ElnaLexerKind.equals then - instruction := _elna_tac_instruction_create(ElnaTacOperator.seq) + instruction := _elna_tac_instruction_create(ElnaTacOperator.equal) elsif token_kind = ElnaLexerKind.remainder then - instruction := _elna_tac_instruction_create(ElnaTacOperator.rem) + instruction := _elna_tac_instruction_create(ElnaTacOperator.remainder) elsif token_kind = ElnaLexerKind.division then - instruction := _elna_tac_instruction_create(ElnaTacOperator.div) + instruction := _elna_tac_instruction_create(ElnaTacOperator.divide) elsif token_kind = ElnaLexerKind.less_than then - instruction := _elna_tac_instruction_create(ElnaTacOperator.slt) + instruction := _elna_tac_instruction_create(ElnaTacOperator.less_than) elsif token_kind = ElnaLexerKind.greater_than then - instruction := _elna_tac_instruction_create(ElnaTacOperator.sgt) + instruction := _elna_tac_instruction_create(ElnaTacOperator.greater_than) elsif token_kind = ElnaLexerKind.less_equal then - instruction := _elna_tac_instruction_create(ElnaTacOperator.sle) + instruction := _elna_tac_instruction_create(ElnaTacOperator.less_or_equal) elsif token_kind = ElnaLexerKind.greater_equal then - instruction := _elna_tac_instruction_create(ElnaTacOperator.sge) + instruction := _elna_tac_instruction_create(ElnaTacOperator.greater_or_equal) elsif token_kind = ElnaLexerKind.not_equal then - instruction := _elna_tac_instruction_create(ElnaTacOperator.sne) + instruction := _elna_tac_instruction_create(ElnaTacOperator.not_equal) end; _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.temporary, 6, 0); _elna_tac_instruction_set_operand(instruction, 2, ElnaTacOperand.stack, 72, 0); @@ -2113,7 +2130,7 @@ begin (* Save the argument on the stack. *) stack_offset := argument_count * 4; - instruction := _elna_tac_instruction_create(ElnaTacOperator.store_word); + instruction := _elna_tac_instruction_create(ElnaTacOperator.store); _elna_tac_instruction_set_operand(instruction, 1, operand_type, operand_value, operand_length); _elna_tac_instruction_set_operand(instruction, 2, ElnaTacOperand.stack, 132 - stack_offset, 0); if first_instruction = 0 then @@ -2135,7 +2152,7 @@ begin stack_offset := argument_count * 4; (* Calculate the stack offset: 132 - (4 * argument_counter) *) - instruction := _elna_tac_instruction_create(ElnaTacOperator.assign); + instruction := _elna_tac_instruction_create(ElnaTacOperator.copy); _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.temporary, 11 + argument_count, 0); _elna_tac_instruction_set_operand(instruction, 2, ElnaTacOperand.stack, 132 - stack_offset, 0); elna_instruction_list_concatenate(current_instruction, instruction); @@ -2143,7 +2160,7 @@ begin goto elna_tac_call_finalize end; - instruction := _elna_tac_instruction_create(ElnaTacOperator.jal); + instruction := _elna_tac_instruction_create(ElnaTacOperator.proc_call); _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.symbol, name, name_length); if first_instruction = 0 then first_instruction := instruction @@ -2319,7 +2336,7 @@ begin parser_node := _dereference_expression_get_pointer(parser_node); first_instruction := _elna_tac_simple_expression(parser_node, symbol_table, operand_type, operand_value, operand_length); - last_instruction := _elna_tac_instruction_create(ElnaTacOperator.assign); + last_instruction := _elna_tac_instruction_create(ElnaTacOperator.copy); _elna_tac_instruction_set_operand(last_instruction, 1, ElnaTacOperand.temporary, 6, 0); _elna_tac_instruction_set_operand(last_instruction, 2, operand_type^, operand_value^, operand_length^); @@ -2335,7 +2352,7 @@ begin elsif node_kind = NodeKind.call then first_instruction := _elna_tac_call(parser_node, symbol_table); - last_instruction := _elna_tac_instruction_create(ElnaTacOperator.assign); + last_instruction := _elna_tac_instruction_create(ElnaTacOperator.copy); _elna_tac_instruction_set_operand(last_instruction, 1, ElnaTacOperand.temporary, 6, 0); _elna_tac_instruction_set_operand(last_instruction, 2, ElnaTacOperand.temporary, 11, 0); @@ -2397,7 +2414,7 @@ begin first_instruction := elna_instruction_list_concatenate(first_instruction, current_instruction); (* Save the assignee address on the stack. *) - current_instruction := _elna_tac_instruction_create(ElnaTacOperator.store_word); + current_instruction := _elna_tac_instruction_create(ElnaTacOperator.store); _elna_tac_instruction_set_operand(current_instruction, 1, ElnaTacOperand.temporary, 6, 0); _elna_tac_instruction_set_operand(current_instruction, 2, ElnaTacOperand.stack, 76, 0); elna_instruction_list_concatenate(first_instruction, current_instruction); @@ -2414,14 +2431,14 @@ begin current_instruction := instruction end; - instruction := _elna_tac_instruction_create(ElnaTacOperator.assign); + instruction := _elna_tac_instruction_create(ElnaTacOperator.copy); _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.temporary, 7, 0); _elna_tac_instruction_set_operand(instruction, 2, ElnaTacOperand.stack, 76, 0); elna_instruction_list_concatenate(current_instruction, instruction); current_instruction := instruction; - instruction := _elna_tac_instruction_create(ElnaTacOperator.store_word); + instruction := _elna_tac_instruction_create(ElnaTacOperator.store); _elna_tac_instruction_set_operand(instruction, 1, operand_type, operand_value, operand_length); _elna_tac_instruction_set_operand(instruction, 2, ElnaTacOperand.temporary, 7, 0); @@ -2466,7 +2483,7 @@ begin return_expression := _return_statement_get_returned(parser_node); first_instruction := _elna_tac_binary_expression(return_expression, symbol_table, @operand_type, @operand_value, @operand_length); - instruction := _elna_tac_instruction_create(ElnaTacOperator.ret); + instruction := _elna_tac_instruction_create(ElnaTacOperator._return); _elna_tac_instruction_set_operand(instruction, 1, operand_type, operand_value, operand_length); return elna_instruction_list_concatenate(first_instruction, instruction) @@ -2541,7 +2558,7 @@ begin condition_label := label_counter; label_counter := label_counter + 1; - current_instruction := _elna_tac_instruction_create(ElnaTacOperator.beqz); + current_instruction := _elna_tac_instruction_create(ElnaTacOperator.jump_if_zero); _elna_tac_instruction_set_operand(current_instruction, 1, operand_type, operand_value, operand_length); _elna_tac_instruction_set_operand(current_instruction, 2, ElnaTacOperand.symbol, condition_label, 0); @@ -3269,7 +3286,7 @@ begin symbol_info := _parameter_info_get_offset(symbol_info); - instruction := _elna_tac_instruction_create(ElnaTacOperator.store_word); + instruction := _elna_tac_instruction_create(ElnaTacOperator.store); _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.temporary, 11 + parameter_counter, 0); _elna_tac_instruction_set_operand(instruction, 2, ElnaTacOperand.stack, symbol_info, 0); if first_instruction = 0 then @@ -3700,14 +3717,14 @@ var next_instruction: Word; begin instruction := _elna_tac_accessor(name_pointer, name_length, field_pointer, field_offset, @first_result, "_get_"); - next_instruction := _elna_tac_instruction_create(ElnaTacOperator.load_word); + next_instruction := _elna_tac_instruction_create(ElnaTacOperator.load); _elna_tac_instruction_set_operand(next_instruction, 1, ElnaTacOperand.temporary, 11, 0); _elna_tac_instruction_set_operand(next_instruction, 2, ElnaTacOperand.temporary, 11, 0); elna_instruction_list_concatenate(instruction, next_instruction); ElnaInstructionDeclaration_set_body(first_result, instruction); instruction := _elna_tac_accessor(name_pointer, name_length, field_pointer, field_offset, @second_result, "_set_"); - next_instruction := _elna_tac_instruction_create(ElnaTacOperator.store_word); + next_instruction := _elna_tac_instruction_create(ElnaTacOperator.store); _elna_tac_instruction_set_operand(next_instruction, 1, ElnaTacOperand.temporary, 12, 0); _elna_tac_instruction_set_operand(next_instruction, 2, ElnaTacOperand.temporary, 11, 0); elna_instruction_list_concatenate(instruction, next_instruction); @@ -3743,7 +3760,7 @@ begin ElnaInstructionDeclaration_set_name(first_result, new_name); ElnaInstructionDeclaration_set_length(first_result, new_length); - instruction := _elna_tac_instruction_create(ElnaTacOperator.assign); + instruction := _elna_tac_instruction_create(ElnaTacOperator.copy); _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.temporary, 11, 0); _elna_tac_instruction_set_operand(instruction, 2, ElnaTacOperand.immediate, type_size, 0); @@ -3889,11 +3906,19 @@ proc _elna_parser_module_declaration(); var parser_node: Word; result: Word; + token_kind: Word; begin result := malloc(_module_declaration_size()); _node_set_kind(result, NodeKind.module_declaration); + (* Skip "program;". *) + _skip_empty_lines(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + parser_node := _elna_parser_type_part(); _module_declaration_set_types(result, parser_node); @@ -4734,8 +4759,14 @@ begin 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 + elsif string_compare(position_start, token_length, "xor", 3) then result := ElnaLexerKind._xor + elsif string_compare(position_start, token_length, "program", 7) then + result := ElnaLexerKind._program + elsif string_compare(position_start, token_length, "module", 6) then + result := ElnaLexerKind._module + elsif string_compare(position_start, token_length, "nil", 3) then + result := ElnaLexerKind.null end; return result end;