diff --git a/boot/stage17/cl.elna b/boot/stage17/cl.elna index ac4ceaa..6ca9ff0 100644 --- a/boot/stage17/cl.elna +++ b/boot/stage17/cl.elna @@ -9,6 +9,7 @@ program; (* - true and false boolean literals. *) (* - the number of local variables is not limited. *) +(* - #size(T). *) type (** @@ -30,6 +31,34 @@ type parameters: Word; count: Word end; + ElnaTreeKind = ( + integer_literal, + string_literal, + character_literal, + boolean_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, + pointer_type_expression, + array_type_expression, + null, + trait_expression + ); ElnaTreeNode = record kind: Word end; @@ -157,6 +186,12 @@ type base: Word; length: Word end; + ElnaTreeTraitExpression = record + kind: Word; + name: Word; + length: Word; + argument: Word + end; (** * Conditional statements is a list of pairs: condition and statements. * Used for example to represent if and elsif blocks with beloning statements. @@ -292,7 +327,8 @@ type double_quote, greater, less, - other + other, + number_sign ); ElnaLexerState = ( start, @@ -311,6 +347,8 @@ type character_escape, string, string_escape, + number_sign, + trait, finish ); ElnaLexerKind = ( @@ -378,33 +416,7 @@ type _goto, eof ); - ElnaTreeKind = ( - integer_literal, - string_literal, - character_literal, - boolean_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, - pointer_type_expression, - array_type_expression, - null - ); + ElnaSymbolInfoKind = (type_info, parameter_info, temporary_info, procedure_info); ElnaTypeKind = (primitive, enumeration, _record, pointer, array); ElnaTacOperator = ( @@ -1048,6 +1060,63 @@ begin return first_instruction end; +proc elna_rtl_store(tac_instruction: Word, next_instruction: ^^ElnaInstructionList); +var + result: ^ElnaInstructionList; + operand_type: Word; + operand_value: Word; + operand_length: Word; + operands: ^ElnaInstructionList; +begin + operands := elna_rtl_load_operand_value(tac_instruction, 1, ElnaRtlRegister.t0); + next_instruction^ := elna_rtl_instruction_create(ElnaRtlOperator.sw); + result := operands; + operands := result^.next; + + elna_rtl_instruction_set_operand(next_instruction^, 1, ElnaRtlOperand.register, ElnaRtlRegister.t0, 0); + + operand_type := _elna_tac_instruction_get_operand_type(tac_instruction, 2); + operand_value := _elna_tac_instruction_get_operand_value(tac_instruction, 2); + operand_length := _elna_tac_instruction_get_operand_length(tac_instruction, 2); + if operand_type = ElnaTacOperand.pseudo then + elna_rtl_instruction_set_operand(next_instruction^, 2, ElnaRtlOperand.pseudo, operand_value, operand_length) + end; + if operands = 0 then + result^.next := next_instruction^ + else + operands^.next := next_instruction^ + end; + return result +end; + +proc elna_rtl_load(tac_instruction: Word, next_instruction: ^^ElnaInstructionList); +var + result: ^ElnaInstructionList; + operand_type: Word; + operand_value: Word; + operand_length: Word; + operands: ^ElnaInstructionList; +begin + operands := elna_rtl_load_operand_value(tac_instruction, 1, ElnaRtlRegister.t0); + next_instruction^ := elna_rtl_instruction_create(ElnaRtlOperator.lw); + result := operands; + operands := result^.next; + + elna_rtl_instruction_set_operand(next_instruction^, 2, ElnaRtlOperand.offset, ElnaRtlRegister.t0, 0); + + operand_type := _elna_tac_instruction_get_operand_type(tac_instruction, 2); + operand_value := _elna_tac_instruction_get_operand_value(tac_instruction, 2); + operand_length := _elna_tac_instruction_get_operand_length(tac_instruction, 2); + elna_rtl_instruction_set_operand(next_instruction^, 1, operand_type, operand_value, operand_length); + + if operands = 0 then + result^.next := next_instruction^ + else + operands^.next := next_instruction^ + end; + return result +end; + proc elna_rtl_instruction(tac_instruction: Word, next_instruction: ^^ElnaInstructionList); var result: ^ElnaInstructionList; @@ -1063,53 +1132,16 @@ begin next_instruction^ := nil; if instruction_kind = ElnaTacOperator.get_address then - operand_type := _elna_tac_instruction_get_operand_type(tac_instruction, 2); - operand_value := _elna_tac_instruction_get_operand_value(tac_instruction, 2); - operand_length := _elna_tac_instruction_get_operand_length(tac_instruction, 2); + result := elna_rtl_instruction_create(ElnaRtlOperator.la); - if operand_type = ElnaTacOperand.symbol then - result := elna_rtl_instruction_create(ElnaRtlOperator.la); - - elna_rtl_copy_operand(tac_instruction, 1, result); - elna_rtl_copy_operand(tac_instruction, 2, result) - elsif operand_type = ElnaTacOperand.pseudo then - result := elna_rtl_instruction_create(ElnaRtlOperator.la); - - elna_rtl_copy_operand(tac_instruction, 1, result); - elna_rtl_instruction_set_operand(result, 2, ElnaRtlOperand.pseudo, operand_value, operand_length) - end + elna_rtl_copy_operand(tac_instruction, 1, result); + elna_rtl_copy_operand(tac_instruction, 2, result) elsif instruction_kind = ElnaTacOperator.add then result := elna_rtl_binary_arithmetic(tac_instruction, next_instruction, ElnaRtlOperator.add) elsif instruction_kind = ElnaTacOperator.load then - operand_type := _elna_tac_instruction_get_operand_type(tac_instruction, 2); - - if operand_type = ElnaTacOperand.pseudo then - operand_value := _elna_tac_instruction_get_operand_value(tac_instruction, 2); - operand_length := _elna_tac_instruction_get_operand_length(tac_instruction, 2); - - result := elna_rtl_instruction_create(ElnaRtlOperator.lw); - elna_rtl_copy_operand(tac_instruction, 1, result); - elna_rtl_instruction_set_operand(result, 2, ElnaRtlOperand.pseudo, operand_value, operand_length) - end + result := elna_rtl_load(tac_instruction, next_instruction) 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; - operands := result^.next; - - elna_rtl_instruction_set_operand(next_instruction^, 1, ElnaRtlOperand.register, ElnaRtlRegister.t0, 0); - - operand_type := _elna_tac_instruction_get_operand_type(tac_instruction, 2); - operand_value := _elna_tac_instruction_get_operand_value(tac_instruction, 2); - operand_length := _elna_tac_instruction_get_operand_length(tac_instruction, 2); - if operand_type = ElnaTacOperand.pseudo then - elna_rtl_instruction_set_operand(next_instruction^, 2, ElnaRtlOperand.pseudo, operand_value, operand_length) - end; - if operands = 0 then - result^.next := next_instruction^ - else - operands^.next := next_instruction^ - end + result := elna_rtl_store(tac_instruction, next_instruction) elsif instruction_kind = ElnaTacOperator.proc_call then result := elna_rtl_call(tac_instruction, next_instruction) elsif instruction_kind = ElnaTacOperator.subtract then @@ -1438,7 +1470,34 @@ begin end end; -proc elna_alloc_load_store(instruction: ^ElnaInstructionList); +proc elna_alloc_store(instruction: ^ElnaInstructionList); +var + old_instruction: ^ElnaInstructionList; + operand_type: Word; + operand_value: Word; + operand_length: Word; + pseudo_symbol: Word; +begin + operand_type := elna_rtl_instruction_get_operand_type(instruction, 2); + operand_value := elna_rtl_instruction_get_operand_value(instruction, 2); + operand_length := elna_rtl_instruction_get_operand_length(instruction, 2); + + if operand_type = ElnaRtlOperand.pseudo then + old_instruction := malloc(elna_rtl_instruction_size()); + memcpy(old_instruction, instruction, elna_rtl_instruction_size()); + + pseudo_symbol := elna_alloc_variable(operand_value, operand_length); + elna_rtl_instruction_set_kind(instruction, ElnaRtlOperator.lw); + + elna_rtl_instruction_set_operand(instruction, 1, ElnaRtlOperand.register, ElnaRtlRegister.t1, 0); + elna_rtl_instruction_set_operand(instruction, 2, ElnaRtlOperand.offset, ElnaRtlRegister.sp, pseudo_symbol); + + instruction^.next := old_instruction; + elna_rtl_instruction_set_operand(old_instruction, 2, ElnaRtlOperand.offset, ElnaRtlRegister.t1, 0) + end +end; + +proc elna_alloc_load(instruction: ^ElnaInstructionList); var old_instruction: ^ElnaInstructionList; operand_type: Word; @@ -1455,37 +1514,14 @@ begin memcpy(old_instruction, instruction, elna_rtl_instruction_size()); pseudo_symbol := elna_alloc_variable(operand_value, operand_length); - elna_rtl_instruction_set_kind(instruction, ElnaRtlOperator.lw); + elna_rtl_instruction_set_kind(old_instruction, ElnaRtlOperator.sw); - elna_rtl_instruction_set_operand(instruction, 1, ElnaRtlOperand.register, ElnaRtlRegister.t1, 0); - elna_rtl_instruction_set_operand(instruction, 2, ElnaRtlOperand.offset, ElnaRtlRegister.sp, pseudo_symbol); - - instruction^.next := old_instruction; elna_rtl_instruction_set_operand(old_instruction, 1, ElnaRtlOperand.register, ElnaRtlRegister.t1, 0); - - goto elna_alloc_load_store_end - end; - - operand_type := elna_rtl_instruction_get_operand_type(instruction, 2); - operand_value := elna_rtl_instruction_get_operand_value(instruction, 2); - operand_length := elna_rtl_instruction_get_operand_length(instruction, 2); - - if operand_type = ElnaRtlOperand.pseudo then - old_instruction := malloc(elna_rtl_instruction_size()); - memcpy(old_instruction, instruction, elna_rtl_instruction_size()); - - pseudo_symbol := elna_alloc_variable(operand_value, operand_length); - elna_rtl_instruction_set_kind(instruction, ElnaRtlOperator.lw); - - elna_rtl_instruction_set_operand(instruction, 1, ElnaRtlOperand.register, ElnaRtlRegister.t1, 0); - elna_rtl_instruction_set_operand(instruction, 2, ElnaRtlOperand.offset, ElnaRtlRegister.sp, pseudo_symbol); + elna_rtl_instruction_set_operand(old_instruction, 2, ElnaRtlOperand.offset, ElnaRtlRegister.sp, pseudo_symbol); instruction^.next := old_instruction; - elna_rtl_instruction_set_operand(old_instruction, 2, ElnaRtlOperand.offset, ElnaRtlRegister.t1, 0); - - goto elna_alloc_load_store_end - end; - .elna_alloc_load_store_end + elna_rtl_instruction_set_operand(instruction, 1, ElnaRtlOperand.register, ElnaRtlRegister.t1, 0) + end end; proc elna_alloc_instruction(instruction: ^ElnaInstructionList); @@ -1532,9 +1568,9 @@ begin elsif instruction_kind = ElnaRtlOperator.la then elna_alloc_load_address(instruction) elsif instruction_kind = ElnaRtlOperator.lw then - elna_alloc_load_store(instruction) + elna_alloc_load(instruction) elsif instruction_kind = ElnaRtlOperator.sw then - elna_alloc_load_store(instruction) + elna_alloc_store(instruction) elsif instruction_kind = ElnaRtlOperator._or then elna_alloc_operation_target(instruction) elsif instruction_kind = ElnaRtlOperator.and then @@ -1991,6 +2027,32 @@ begin return elna_instruction_list_concatenate(first_instruction, next_instruction) end; +proc elna_parser_trait_expression(); +var + result: ^ElnaTreeTraitExpression; + token_kind: Word; +begin + printf("# Comment\n\0"); + fflush(nil); + + result := malloc(ElnaTreeTraitExpression_size()); + result^.kind := ElnaTreeKind.trait_expression; + + result^.name := _elna_lexer_global_get_start(); + result^.length := _elna_lexer_global_get_end() - result^.name; + + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + result^.argument := elna_parser_type_expression(); + + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + return result +end; + proc elna_parser_simple_expression(); var current_character: Word; @@ -2010,6 +2072,8 @@ begin parser_node := elna_parser_boolean_literal() elsif token_kind = ElnaLexerKind.null then parser_node := elna_parser_nil_literal() + elsif token_kind = ElnaLexerKind.trait then + parser_node := elna_parser_trait_expression() elsif token_kind = ElnaLexerKind.identifier then parser_node := elna_parser_variable_expression() end; @@ -2033,26 +2097,43 @@ end; proc elna_parser_designator(); var simple_expression: Word; - token_kind1: Word; + token_kind: Word; begin simple_expression := elna_parser_simple_expression(); .elna_parser_designator_loop; - _elna_lexer_read_token(@token_kind1); + _elna_lexer_read_token(@token_kind); - if token_kind1 = ElnaLexerKind.hat then + if token_kind = ElnaLexerKind.hat then simple_expression := elna_parser_dereference_expression(simple_expression); goto elna_parser_designator_loop - elsif token_kind1 = ElnaLexerKind.dot then + elsif token_kind = ElnaLexerKind.dot then simple_expression := elna_parser_field_access_expression(simple_expression); goto elna_parser_designator_loop - elsif token_kind1 = ElnaLexerKind.left_paren then + elsif token_kind = ElnaLexerKind.left_paren then simple_expression := elna_parser_call(simple_expression); goto elna_parser_designator_loop end; return simple_expression end; +proc elna_tac_trait_expression(trait_node: ^ElnaTreeTraitExpression, operand_type: Word, operand_value: Word, operand_length: Word); +var + symbol: ^ElnaSymbolTypeInfo; + info_type: ^ElnaType; + parser_node: ^ElnaTreeNamedTypeExpression; +begin + parser_node := trait_node^.argument; + symbol := _symbol_table_lookup(@symbol_table_global, parser_node^.name, parser_node^.length); + info_type := symbol^._type; + + operand_type^ := ElnaTacOperand.immediate; + operand_value^ := info_type^.size; + operand_length^ := 0; + + return nil +end; + proc elna_tac_simple_expression(parser_node: ^ElnaTreeNode, symbol_table: Word, operand_type: Word, operand_value: Word, operand_length: Word); var instruction: Word; @@ -2067,6 +2148,8 @@ begin instruction := elna_tac_boolean_literal(parser_node, operand_type, operand_value, operand_length) elsif parser_node^.kind = ElnaTreeKind.null then instruction := elna_tac_nil_literal(parser_node, operand_type, operand_value, operand_length) + elsif parser_node^.kind = ElnaTreeKind.trait_expression then + instruction := elna_tac_trait_expression(parser_node, operand_type, operand_value, operand_length) else instruction := elna_tac_variable_expression(parser_node, symbol_table, operand_type, operand_value, operand_length) end; @@ -2112,7 +2195,7 @@ proc elna_tac_unary_expression(parser_node: ^ElnaTreeUnaryExpression, symbol_tab var token_kind: Word; operator: Word; - operand: Word; + operand: ^ElnaTreeExpression; is_address: Word; first_instruction: Word; instruction: Word; @@ -2152,23 +2235,13 @@ begin operand_value^ := "$unary"; operand_length^ := 6 elsif is_address then - if operand_type^ = ElnaTacOperand.pseudo then - 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^); + instruction := _elna_tac_instruction_create(ElnaTacOperator.load); + _elna_tac_instruction_set_operand(instruction, 1, operand_type^, operand_value^, operand_length^); + _elna_tac_instruction_set_operand(instruction, 2, ElnaTacOperand.pseudo, "$unary", 6); - operand_type^ := ElnaTacOperand.temporary; - operand_value^ := 6; - operand_length^ := 0 - else - instruction := _elna_tac_instruction_create(ElnaTacOperator.load); - _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.pseudo, "$unary", 6); - _elna_tac_instruction_set_operand(instruction, 2, operand_type^, operand_value^, operand_length^); - - operand_type^ := ElnaTacOperand.pseudo; - operand_value^ := "$unary"; - operand_length^ := 6 - end + operand_type^ := ElnaTacOperand.pseudo; + operand_value^ := "$unary"; + operand_length^ := 6 else instruction := _elna_tac_instruction_create(ElnaTacOperator.copy); _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.pseudo, "$unary", 6); @@ -2490,21 +2563,21 @@ end; proc elna_parser_goto_statement(); var - token_kind1: Word; - result1: ^ElnaTreeGotoStatement; + token_kind: Word; + result: ^ElnaTreeGotoStatement; begin _elna_lexer_skip_token(); - _elna_lexer_read_token(@token_kind1); + _elna_lexer_read_token(@token_kind); - result1 := malloc(ElnaTreeGotoStatement_size()); - result1^.kind := ElnaTreeKind.goto_statement; - result1^.next := nil; - result1^.label := _elna_lexer_global_get_start(); - result1^.length := _elna_lexer_global_get_end() - result1^.label; + result := malloc(ElnaTreeGotoStatement_size()); + result^.kind := ElnaTreeKind.goto_statement; + result^.next := nil; + result^.label := _elna_lexer_global_get_start(); + result^.length := _elna_lexer_global_get_end() - result^.label; _elna_lexer_skip_token(); - return result1 + return result end; proc elna_tac_goto_statement(parser_node: ^ElnaTreeGotoStatement); @@ -2632,17 +2705,7 @@ begin if parser_node^.kind = ElnaTreeKind.dereference_expression then dereference_expression := parser_node; first_instruction := elna_tac_designator(dereference_expression^.pointer, symbol_table, is_address, operand_type, operand_value, operand_length); - - last_instruction := _elna_tac_instruction_create(ElnaTacOperator.copy); - _elna_tac_instruction_set_operand(last_instruction, 1, ElnaTacOperand.pseudo, "$unary", 6); - _elna_tac_instruction_set_operand(last_instruction, 2, operand_type^, operand_value^, operand_length^); - - operand_type^ := ElnaTacOperand.pseudo; - operand_value^ := "$unary"; - operand_length^ := 6; - - is_address^ := 1; - first_instruction := elna_instruction_list_concatenate(first_instruction, last_instruction); + is_address^ := 1 elsif parser_node^.kind = ElnaTreeKind.field_access_expression then field_access_expression := parser_node; expression_type := field_access_expression^.type_decoration; @@ -4824,7 +4887,7 @@ begin _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, 36, ElnaLexerClass.number_sign); _assign_at(@classification, 37, ElnaLexerClass.other); _assign_at(@classification, 38, ElnaLexerClass.single); _assign_at(@classification, 39, ElnaLexerClass.single); @@ -4938,9 +5001,9 @@ var 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. *) + There are 23 character classes, so a transition row 8 * 23 = 184 bytes long. *) row_position := current_state - 1; - row_position := row_position * 176; + row_position := row_position * 184; column_position := character_class - 1; column_position := column_position * 8; @@ -4999,7 +5062,8 @@ begin _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) + _elna_lexer_set_transition(current_state, ElnaLexerClass.other, default_action, next_state); + _elna_lexer_set_transition(current_state, ElnaLexerClass.number_sign, default_action, next_state) end; (** @@ -5035,6 +5099,7 @@ begin _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); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.number_sign, ElnaLexerAction.accumulate, ElnaLexerState.number_sign); (* Colon state. *) _elna_lexer_default_transition(ElnaLexerState.colon, ElnaLexerAction.finalize, ElnaLexerState.finish); @@ -5119,7 +5184,21 @@ begin (* 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) + _elna_lexer_set_transition(ElnaLexerState.string_escape, ElnaLexerClass.eof, ElnaLexerAction.none, ElnaLexerState.finish); + + (* Number sign state. *) + _elna_lexer_default_transition(ElnaLexerState.number_sign, ElnaLexerAction.key_id, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.number_sign, ElnaLexerClass.alpha, ElnaLexerAction.accumulate, ElnaLexerState.trait); + _elna_lexer_set_transition(ElnaLexerState.number_sign, ElnaLexerClass.hex, ElnaLexerAction.accumulate, ElnaLexerState.trait); + _elna_lexer_set_transition(ElnaLexerState.number_sign, ElnaLexerClass.x, ElnaLexerAction.accumulate, ElnaLexerState.trait); + + (* Trait state. *) + _elna_lexer_default_transition(ElnaLexerState.trait, ElnaLexerAction.key_id, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.trait, ElnaLexerClass.digit, ElnaLexerAction.accumulate, ElnaLexerState.trait); + _elna_lexer_set_transition(ElnaLexerState.trait, ElnaLexerClass.alpha, ElnaLexerAction.accumulate, ElnaLexerState.trait); + _elna_lexer_set_transition(ElnaLexerState.trait, ElnaLexerClass.hex, ElnaLexerAction.accumulate, ElnaLexerState.trait); + _elna_lexer_set_transition(ElnaLexerState.trait, ElnaLexerClass.zero, ElnaLexerAction.accumulate, ElnaLexerState.trait); + _elna_lexer_set_transition(ElnaLexerState.trait, ElnaLexerClass.x, ElnaLexerAction.accumulate, ElnaLexerState.trait) end; (** @@ -5133,15 +5212,15 @@ 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. + * Each transition table entry is 8 bytes long. The table has 19 rows (transition states) + * and 23 columns (character classes), so 3496 = 8 * 19 * 23. *) proc _elna_lexer_global_state(); var result: Word; begin result := _elna_lexer_get_transition_table(); - return result + 2992 + return result + 3496 end; (** @@ -5274,7 +5353,9 @@ begin result := ElnaLexerKind.identifier; token_length := position_end - position_start; - if string_compare(position_start, token_length, "const", 5) then + if _load_byte(position_start) = '#' then + result := ElnaLexerKind.trait + elsif 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 diff --git a/boot/stage18/cl.elna b/boot/stage18/cl.elna new file mode 100644 index 0000000..f579c0a --- /dev/null +++ b/boot/stage18/cl.elna @@ -0,0 +1,5550 @@ +(* + * 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/. + *) +program; + +(* Stage 18 compiler. *) + +type + (** + * List of intermediate representation items. + *) + ElnaInstructionList = record + next: Word + end; + ElnaInstructionModule = record + data: Word; + code: Word + end; + ElnaInstructionDeclaration = record + next: Word; + name: Word; + length: Word; + body: Word; + stack: Word; + parameters: Word; + count: Word + end; + ElnaTreeKind = ( + integer_literal, + string_literal, + character_literal, + boolean_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, + pointer_type_expression, + array_type_expression, + null, + trait_expression + ); + ElnaTreeNode = record + kind: Word + end; + ElnaTreeExpression = record + kind: Word; + type_decoration: Word + end; + ElnaTreeIntegerLiteral = record + kind: Word; + type_decoration: Word; + value: Word; + length: Word + end; + ElnaTreeCharacterLiteral = record + kind: Word; + type_decoration: Word; + value: Word; + length: Word + end; + ElnaTreeNilLiteral = record + kind: Word; + type_decoration: Word + end; + ElnaTreeBooleanLiteral = record + kind: Word; + type_decoration: Word; + value: Word + end; + ElnaTreeVariableExpression = record + kind: Word; + type_decoration: Word; + name: Word; + length: Word + end; + ElnaTreeStringLiteral = record + kind: Word; + type_decoration: Word; + value: Word; + length: Word + end; + ElnaTreeDereferenceExpression = record + kind: Word; + type_decoration: Word; + pointer: Word + end; + ElnaTreeBinaryExpression = record + kind: Word; + type_decoration: Word; + lhs: Word; + rhs: Word; + operator: Word + end; + ElnaTreeUnaryExpression = record + kind: Word; + type_decoration: Word; + operand: Word; + operator: Word + end; + + (** + * All statements are chained into a list. Next contains a pointer to the next + * statement in the statement list. + *) + ElnaTreeStatement = record + kind: Word; + next: Word + end; + ElnaTreeIfStatement = record + kind: Word; + next: Word; + conditionals: Word; + _else: Word + end; + ElnaTreeGotoStatement = record + kind: Word; + next: Word; + label: Word; + length: Word + end; + ElnaTreeAssignStatement = record + kind: Word; + next: Word; + assignee: Word; + assignment: Word + end; + ElnaTreeReturnStatement = record + kind: Word; + next: Word; + returned: Word + end; + ElnaTreeLabelDeclaration = record + kind: Word; + next: Word; + label: Word; + length: Word + end; + ElnaTreeFieldAccessExpression = record + kind: Word; + type_decoration: Word; + aggregate: Word; + field: Word; + length: Word + end; + ElnaTreeEnumerationTypeExpression = record + kind: Word; + members: Word; + length: Word + end; + ElnaTreeRecordTypeExpression = record + kind: Word; + members: Word; + length: Word + end; + ElnaTreeNamedTypeExpression = record + kind: Word; + name: Word; + length: Word + end; + ElnaTreePointerTypeExpression = record + kind: Word; + base: Word + end; + ElnaTreeArrayTypeExpression = record + kind: Word; + base: Word; + length: Word + end; + ElnaTreeTraitExpression = record + kind: Word; + name: Word; + length: Word; + argument: Word + end; + (** + * Conditional statements is a list of pairs: condition and statements. + * Used for example to represent if and elsif blocks with beloning statements. + *) + ElnaTreeConditionalStatements = record + condition: Word; + statements: Word; + next: Word + end; + ElnaTreeDeclaration = record + kind: Word; + next: Word; + name: Word; + length: Word + end; + ElnaTreeModuleDeclaration = record + kind: Word; + types: Word; + globals: Word; + procedures: Word + end; + ElnaTreeProcedureDeclaration = record + kind: Word; + next: Word; + name: Word; + length: Word; + body: Word; + temporaries: Word; + parameters: Word + end; + ElnaTreeTypeDeclaration = record + kind: Word; + next: Word; + name: Word; + length: Word; + _type: Word + end; + ElnaTreeVariableDeclaration = record + kind: Word; + next: Word; + name: Word; + length: Word; + _type: Word + end; + + ElnaType = record + kind: Word; + size: Word + end; + ElnaTypeEnumeration = record + kind: Word; + size: Word; + members: Word; + length: Word + end; + ElnaTypeField = record + name: Word; + length: Word; + field_type: Word + end; + ElnaTypeRecord = record + kind: Word; + size: Word; + members: Word; + length: Word + end; + ElnaTypePointer = record + kind: Word; + size: Word; + base: Word + end; + ElnaTypeArray = record + kind: Word; + size: Word; + base: Word; + length: Word + end; + ElnaSymbolInfo = record + kind: Word + end; + ElnaSymbolTypeInfo = record + kind: Word; + _type: Word + end; + ElnaSymbolTemporaryInfo = record + kind: Word; + offset: Word; + variable_type: Word + end; + ElnaSymbolProcedureInfo = record + kind: Word; + symbol_table: Word + end; + + ElnaErrorList = record + first: Word; + last: Word + end; + ElnaError = record + next: 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, + number_sign + ); + ElnaLexerState = ( + start, + colon, + identifier, + decimal, + leading_zero, + greater, + minus, + left_paren, + less, + dot, + comment, + closing_comment, + character, + character_escape, + string, + string_escape, + number_sign, + trait, + finish + ); + ElnaLexerKind = ( + identifier, + _const, + _var, + _proc, + _type, + _begin, + _end, + _if, + _then, + _else, + _elsif, + _while, + _do, + _extern, + _record, + boolean, + 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 + ); + + ElnaSymbolInfoKind = (type_info, parameter_info, temporary_info, procedure_info); + ElnaTypeKind = (primitive, enumeration, _record, pointer, array); + ElnaTacOperator = ( + get_address, + add, + load, + store, + proc_call, + copy, + subtract, + divide, + remainder, + multiply, + _xor, + _or, + and, + less_than, + greater_than, + less_or_equal, + greater_or_equal, + equal, + not_equal, + negate, + complement, + jump, + jump_if_zero, + jump_if_not_zero, + label, + _return + ); + ElnaRtlOperator = ( + li, + la, + add, + addi, + lw, + sw, + jal, + move, + sub, + div, + rem, + mul, + _xor, + _or, + and, + seqz, + snez, + slt, + xori, + neg, + not, + j, + beqz, + bnez, + label, + allocate_stack, + ret + ); + ElnaTacOperand = (temporary, immediate, symbol, pseudo, list); + ElnaRtlOperand = (register, immediate, symbol, pseudo, offset); + ElnaRtlRegister = ( + 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; + variable_map: Array; + + source_code: Word; + compiler_strings_position: Word; + compiler_strings_length: Word; + label_counter: Word; + symbol_table_store: Word; + temporary_variable_counter: 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 + counter1: Word; + current_byte1: Word; +begin + (* Reset the counter. *) + counter1 := 0; + + .string_length_loop; + string := string + 1; + + current_byte1 := _load_byte(string); + if current_byte1 <> '"' then + counter1 := counter1 + 1; + goto string_length_loop + end; + + return counter1 +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 + contents1: Word; + result1: Word; + current_byte1: Word; +begin + contents1 := string + 1; + result1 := compiler_strings_length; + + .add_string_loop; + current_byte1 := _load_byte(contents1); + if current_byte1 <> '"' then + _store_byte(current_byte1, compiler_strings_position); + compiler_strings_position := compiler_strings_position + 1; + contents1 := contents1 + 1; + + if current_byte1 <> '\\' then + compiler_strings_length := compiler_strings_length + 1 + end; + goto add_string_loop + end; + + return result1 +end; + +(** + * Writes to the standard output. + * + * Parameters: + * buffer - Buffer. + * size - Buffer length. + *) +proc _write_s(buffer: Word, size: Word); +begin + write(1, buffer, size) +end; + +(** + * Writes a number to the standard output. + * + * Parameters: + * number - Whole number. + *) +proc _write_i(number: Word); +begin + printf("%i\0", number); + fflush(nil) +end; + +(** + * Writes a character from a0 into the standard output. + * + * Parameters: + * character - Character to write. + *) +proc _write_c(character: Word); +begin + write(1, @character, 1) +end; + +(** + * Write null terminated string. + * + * Parameters: + * string - String. + *) +proc _write_z(string: Word); +begin + printf("%s\0", string); + fflush(nil) +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_underscore1: Word; +begin + is_underscore1 := character = '_'; + + return isalpha(character) or is_underscore1 +end; + +proc _is_alnum(character: Word); + return _is_alpha(character) or isdigit(character) +end; + +proc _elna_tac_instruction_size(); + return 44 +end; + +proc _elna_tac_instruction_get_kind(this: Word); +begin + this := this + 4; + return this^ +end; + +proc _elna_tac_instruction_set_kind(this: Word, value: Word); +begin + this := this + 4; + this^ := value +end; + +proc elna_instruction_list_concatenate(this: Word, value: Word); +var + start1: Word; +begin + if this = 0 then + start1 := value; + goto elna_instruction_list_concatenate_end + else + start1 := this + end; + .elna_instruction_list_concatenate_loop; + if value <> 0 then + if this^ <> 0 then + this := this^; + goto elna_instruction_list_concatenate_loop + end + end; + this^ := value; + .elna_instruction_list_concatenate_end; + return start1 +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 + result1: Word; +begin + result1 := malloc(_elna_tac_instruction_size()); + + _elna_tac_instruction_set_kind(result1, kind); + elna_instruction_list_concatenate(result1, 0); + + return result1 +end; + +proc elna_rtl_instruction_create(kind: Word); +var + result1: ^ElnaInstructionList; +begin + result1 := malloc(elna_rtl_instruction_size()); + + elna_rtl_instruction_set_kind(result1, kind); + result1^.next := nil; + + return result1 +end; + +proc elna_rtl_instruction_size(); + return 44 +end; + +proc elna_rtl_instruction_get_kind(this: Word); +begin + this := this + 4; + return this^ +end; + +proc elna_rtl_instruction_set_kind(this: Word, value: Word); +begin + this := this + 4; + this^ := value +end; + +proc elna_rtl_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_rtl_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_rtl_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_rtl_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_rtl_load_operand_value(tac_instruction: Word, operand_number: Word, into: Word); +var + result: ^ElnaInstructionList; + operand_value: Word; + operand_length: Word; + operand_type: Word; + next_instruction: Word; +begin + operand_value := _elna_tac_instruction_get_operand_value(tac_instruction, operand_number); + operand_length := _elna_tac_instruction_get_operand_length(tac_instruction, operand_number); + operand_type := _elna_tac_instruction_get_operand_type(tac_instruction, operand_number); + + if operand_type = ElnaTacOperand.immediate then + result := elna_rtl_instruction_create(ElnaRtlOperator.li); + elna_rtl_instruction_set_operand(result, 1, ElnaRtlOperand.register, into, 0); + elna_rtl_instruction_set_operand(result, 2, ElnaRtlOperand.immediate, operand_value, operand_length) + elsif operand_type = ElnaTacOperand.symbol then + result := elna_rtl_instruction_create(ElnaRtlOperator.la); + elna_rtl_instruction_set_operand(result, 1, ElnaRtlOperand.register, into, 0); + elna_rtl_instruction_set_operand(result, 2, ElnaRtlOperand.symbol, operand_value, operand_length); + + next_instruction := elna_rtl_instruction_create(ElnaRtlOperator.lw); + elna_rtl_instruction_set_operand(next_instruction, 1, ElnaRtlOperand.register, into, 0); + elna_rtl_instruction_set_operand(next_instruction, 2, ElnaRtlOperand.offset, into, 0); + + result^.next := next_instruction + elsif operand_type = ElnaTacOperand.temporary then + result := elna_rtl_instruction_create(ElnaRtlOperator.move); + elna_rtl_instruction_set_operand(result, 1, ElnaRtlOperand.register, into, 0); + elna_rtl_instruction_set_operand(result, 2, ElnaRtlOperand.register, operand_value, 0) + elsif operand_type = ElnaTacOperand.pseudo then + result := elna_rtl_instruction_create(ElnaRtlOperator.move); + elna_rtl_instruction_set_operand(result, 1, ElnaRtlOperand.register, into, 0); + elna_rtl_instruction_set_operand(result, 2, ElnaRtlOperand.pseudo, operand_value, operand_length) + end; + + return result +end; + +proc elna_rtl_load_operand_address(tac_instruction: Word, operand_number: Word, into: Word); +var + result: Word; + operand_value: Word; + operand_length: Word; + operand_type: Word; +begin + operand_value := _elna_tac_instruction_get_operand_value(tac_instruction, operand_number); + operand_length := _elna_tac_instruction_get_operand_length(tac_instruction, operand_number); + operand_type := _elna_tac_instruction_get_operand_type(tac_instruction, operand_number); + + if operand_type = ElnaTacOperand.symbol then + result := elna_rtl_instruction_create(ElnaRtlOperator.la); + elna_rtl_instruction_set_operand(result, 1, ElnaRtlOperand.register, into, 0); + elna_rtl_instruction_set_operand(result, 2, ElnaRtlOperand.symbol, operand_value, operand_length) + elsif operand_type = ElnaTacOperand.pseudo then + result := elna_rtl_instruction_create(ElnaRtlOperator.la); + elna_rtl_instruction_set_operand(result, 1, ElnaRtlOperand.register, into, 0); + elna_rtl_instruction_set_operand(result, 2, ElnaRtlOperand.pseudo, operand_value, operand_length) + end; + + return result +end; + +proc elna_rtl_binary_operands(tac_instruction: Word, next_instruction: Word); +var + lhs: ^ElnaInstructionList; + rhs: ^ElnaInstructionList; +begin + lhs := elna_rtl_load_operand_value(tac_instruction, 2, ElnaRtlRegister.t2); + rhs := elna_rtl_load_operand_value(tac_instruction, 3, ElnaRtlRegister.t3); + + next_instruction^ := lhs^.next; + if next_instruction^ = 0 then + lhs^.next := rhs + else + next_instruction^^ := rhs + end; + next_instruction^ := rhs^.next; + if next_instruction^ = 0 then + next_instruction^ := rhs + end; + + return lhs +end; + +proc elna_rtl_binary_arithmetic(tac_instruction: Word, next_instruction: Word, operation: Word); +var + lhs: Word; + binary_result: Word; + intermediate_instruction: ^ElnaInstructionList; +begin + lhs := elna_rtl_binary_operands(tac_instruction, next_instruction); + binary_result := elna_rtl_instruction_create(operation); + + elna_rtl_copy_operand(tac_instruction, 1, binary_result); + elna_rtl_instruction_set_operand(binary_result, 2, ElnaRtlOperand.register, ElnaRtlRegister.t2, 0); + elna_rtl_instruction_set_operand(binary_result, 3, ElnaRtlOperand.register, ElnaRtlRegister.t3, 0); + elna_rtl_instruction_set_kind(binary_result, operation); + + intermediate_instruction := next_instruction^; + intermediate_instruction^.next := binary_result; + next_instruction^ := binary_result; + + return lhs +end; + +proc elna_rtl_binary_equality(tac_instruction: Word, instruction_kind: Word, next_instruction: Word); +var + operands: Word; + intermediate_instruction: ^ElnaInstructionList; + operating_instruction: ^ElnaInstructionList; + binary_result: Word; +begin + operands := elna_rtl_binary_operands(tac_instruction, next_instruction); + operating_instruction := elna_rtl_instruction_create(ElnaRtlOperator._xor); + + elna_rtl_instruction_set_operand(operating_instruction, 1, ElnaRtlOperand.register, ElnaRtlRegister.t2, 0); + elna_rtl_instruction_set_operand(operating_instruction, 2, ElnaRtlOperand.register, ElnaRtlRegister.t2, 0); + elna_rtl_instruction_set_operand(operating_instruction, 3, ElnaRtlOperand.register, ElnaRtlRegister.t3, 0); + + intermediate_instruction := next_instruction^; + intermediate_instruction^.next := operating_instruction; + + binary_result := elna_rtl_instruction_create(instruction_kind); + elna_rtl_copy_operand(tac_instruction, 1, binary_result); + elna_rtl_instruction_set_operand(binary_result, 2, ElnaRtlOperand.register, ElnaRtlRegister.t2, 0); + + intermediate_instruction := next_instruction^; + operating_instruction^.next := binary_result; + next_instruction^ := binary_result; + + return operands +end; + +proc elna_rtl_copy_operand(tac_instruction: Word, number: Word, rtl_instruction: Word); +var + operand_length: Word; + operand_type: Word; + operand_value: Word; +begin + operand_type := _elna_tac_instruction_get_operand_type(tac_instruction, number); + operand_value := _elna_tac_instruction_get_operand_value(tac_instruction, number); + operand_length := _elna_tac_instruction_get_operand_length(tac_instruction, number); + + 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_unary(tac_instruction: Word, rtl_operator: Word, next_instruction: Word); +var + result: ^ElnaInstructionList; +begin + result := elna_rtl_load_operand_value(tac_instruction, 2, ElnaRtlRegister.t0); + next_instruction^ := elna_rtl_instruction_create(rtl_operator); + elna_rtl_copy_operand(tac_instruction, 1, result); + elna_rtl_instruction_set_operand(result, 2, ElnaRtlOperand.register, ElnaRtlRegister.t0); + result^.next := next_instruction^; + + return result +end; + +proc elna_rtl_call(tac_instruction: Word, next_instruction: ^^ElnaInstructionList); +var + argument_count: Word; + current_argument: Word; + argument_type: Word; + argument_value: Word; + argument_length: Word; + argument_move: Word; + current_register: Word; + first_instruction: Word; + current_instruction: Word; + name: Word; + name_length: Word; +begin + current_register := 0; + first_instruction := nil; + + current_argument := _elna_tac_instruction_get_operand_value(tac_instruction, 2); + argument_count := _elna_tac_instruction_get_operand_length(tac_instruction, 2); + + name := _elna_tac_instruction_get_operand_value(tac_instruction, 1); + name_length := _elna_tac_instruction_get_operand_length(tac_instruction, 1); + + .elna_rtl_call_loop; + + if argument_count > 0 then + argument_count := argument_count - 1; + + argument_type := current_argument^; + current_argument := current_argument + 4; + argument_value := current_argument^; + current_argument := current_argument + 4; + argument_length := current_argument^; + current_argument := current_argument + 4; + + argument_move := elna_rtl_instruction_create(ElnaRtlOperator.move); + elna_rtl_instruction_set_operand(argument_move, 1, ElnaRtlOperand.register, ElnaRtlRegister.a0 + current_register, 0); + elna_rtl_instruction_set_operand(argument_move, 2, argument_type, argument_value, argument_length); + + if first_instruction = nil then + first_instruction := argument_move + else + elna_instruction_list_concatenate(current_instruction, argument_move) + end; + current_instruction := argument_move; + + current_register := current_register + 1; + + goto elna_rtl_call_loop + end; + argument_move := elna_rtl_instruction_create(ElnaRtlOperator.jal); + elna_rtl_copy_operand(tac_instruction, 1, argument_move); + + if first_instruction = nil then + first_instruction := argument_move + else + elna_instruction_list_concatenate(current_instruction, argument_move) + end; + next_instruction^ := argument_move; + + return first_instruction +end; + +proc elna_rtl_store(tac_instruction: Word, next_instruction: ^^ElnaInstructionList); +var + result: ^ElnaInstructionList; + operand_type: Word; + operand_value: Word; + operand_length: Word; + operands: ^ElnaInstructionList; +begin + operands := elna_rtl_load_operand_value(tac_instruction, 1, ElnaRtlRegister.t0); + next_instruction^ := elna_rtl_instruction_create(ElnaRtlOperator.sw); + result := operands; + operands := result^.next; + + elna_rtl_instruction_set_operand(next_instruction^, 1, ElnaRtlOperand.register, ElnaRtlRegister.t0, 0); + + operand_type := _elna_tac_instruction_get_operand_type(tac_instruction, 2); + operand_value := _elna_tac_instruction_get_operand_value(tac_instruction, 2); + operand_length := _elna_tac_instruction_get_operand_length(tac_instruction, 2); + if operand_type = ElnaTacOperand.pseudo then + elna_rtl_instruction_set_operand(next_instruction^, 2, ElnaRtlOperand.pseudo, operand_value, operand_length) + end; + if operands = 0 then + result^.next := next_instruction^ + else + operands^.next := next_instruction^ + end; + return result +end; + +proc elna_rtl_load(tac_instruction: Word, next_instruction: ^^ElnaInstructionList); +var + result: ^ElnaInstructionList; + operand_type: Word; + operand_value: Word; + operand_length: Word; + operands: ^ElnaInstructionList; +begin + operands := elna_rtl_load_operand_value(tac_instruction, 1, ElnaRtlRegister.t0); + next_instruction^ := elna_rtl_instruction_create(ElnaRtlOperator.lw); + result := operands; + operands := result^.next; + + elna_rtl_instruction_set_operand(next_instruction^, 2, ElnaRtlOperand.offset, ElnaRtlRegister.t0, 0); + + operand_type := _elna_tac_instruction_get_operand_type(tac_instruction, 2); + operand_value := _elna_tac_instruction_get_operand_value(tac_instruction, 2); + operand_length := _elna_tac_instruction_get_operand_length(tac_instruction, 2); + elna_rtl_instruction_set_operand(next_instruction^, 1, operand_type, operand_value, operand_length); + + if operands = 0 then + result^.next := next_instruction^ + else + operands^.next := next_instruction^ + end; + return result +end; + +proc elna_rtl_instruction(tac_instruction: Word, next_instruction: ^^ElnaInstructionList); +var + result: ^ElnaInstructionList; + instruction_kind: Word; + operand_type: Word; + operand_value: Word; + operand_length: Word; + operands: ^ElnaInstructionList; + intermediate_instruction: ^ElnaInstructionList; +begin + result := malloc(elna_rtl_instruction_size()); + instruction_kind := _elna_tac_instruction_get_kind(tac_instruction); + next_instruction^ := nil; + + if instruction_kind = ElnaTacOperator.get_address then + result := elna_rtl_instruction_create(ElnaRtlOperator.la); + + elna_rtl_copy_operand(tac_instruction, 1, result); + elna_rtl_copy_operand(tac_instruction, 2, result) + elsif instruction_kind = ElnaTacOperator.add then + result := elna_rtl_binary_arithmetic(tac_instruction, next_instruction, ElnaRtlOperator.add) + elsif instruction_kind = ElnaTacOperator.load then + result := elna_rtl_load(tac_instruction, next_instruction) + elsif instruction_kind = ElnaTacOperator.store then + result := elna_rtl_store(tac_instruction, next_instruction) + elsif instruction_kind = ElnaTacOperator.proc_call then + result := elna_rtl_call(tac_instruction, next_instruction) + elsif instruction_kind = ElnaTacOperator.subtract then + result := elna_rtl_binary_arithmetic(tac_instruction, next_instruction, ElnaRtlOperator.sub) + elsif instruction_kind = ElnaTacOperator.multiply then + result := elna_rtl_binary_arithmetic(tac_instruction, next_instruction, ElnaRtlOperator.mul) + elsif instruction_kind = ElnaTacOperator.divide then + result := elna_rtl_binary_arithmetic(tac_instruction, next_instruction, ElnaRtlOperator.div) + 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) + elsif instruction_kind = ElnaTacOperator._or then + 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.less_than then + result := elna_rtl_binary_arithmetic(tac_instruction, next_instruction, ElnaRtlOperator.slt) + elsif instruction_kind = ElnaTacOperator.greater_than then + operands := elna_rtl_binary_operands(tac_instruction, next_instruction); + + result := elna_rtl_instruction_create(ElnaRtlOperator.slt); + elna_rtl_copy_operand(tac_instruction, 1, result); + elna_rtl_instruction_set_operand(result, 2, ElnaRtlOperand.register, ElnaRtlRegister.t3, 0); + elna_rtl_instruction_set_operand(result, 3, ElnaRtlOperand.register, ElnaRtlRegister.t2, 0); + + intermediate_instruction := next_instruction^; + intermediate_instruction^.next := result; + next_instruction^ := result; + + result := operands; + elna_rtl_instruction_set_kind(next_instruction^, ElnaRtlOperator.slt) + 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); + + elna_rtl_instruction_set_operand(intermediate_instruction, 1, ElnaRtlOperand.register, ElnaRtlRegister.t2, 0); + elna_rtl_instruction_set_operand(intermediate_instruction, 2, ElnaRtlOperand.register, ElnaRtlRegister.t3, 0); + elna_rtl_instruction_set_operand(intermediate_instruction, 3, ElnaRtlOperand.register, ElnaRtlRegister.t2, 0); + result := next_instruction^; + result^.next := intermediate_instruction; + next_instruction^ := intermediate_instruction; + + result := elna_rtl_instruction_create(ElnaRtlOperator.xori); + elna_rtl_copy_operand(tac_instruction, 1, result); + elna_rtl_instruction_set_operand(result, 2, ElnaRtlOperand.register, ElnaRtlRegister.t2, 0); + elna_rtl_instruction_set_operand(result, 3, ElnaRtlOperand.immediate, 1, 0); + intermediate_instruction := next_instruction^; + intermediate_instruction^.next := result; + next_instruction^ := result; + result := operands + 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); + + elna_rtl_instruction_set_operand(intermediate_instruction, 1, ElnaRtlOperand.register, ElnaRtlRegister.t2, 0); + elna_rtl_instruction_set_operand(intermediate_instruction, 2, ElnaRtlOperand.register, ElnaRtlRegister.t2, 0); + elna_rtl_instruction_set_operand(intermediate_instruction, 3, ElnaRtlOperand.register, ElnaRtlRegister.t3, 0); + result := next_instruction^; + result^.next := intermediate_instruction; + next_instruction^ := intermediate_instruction; + + result := elna_rtl_instruction_create(ElnaRtlOperator.xori); + elna_rtl_copy_operand(tac_instruction, 1, result); + elna_rtl_instruction_set_operand(result, 2, ElnaRtlOperand.register, ElnaRtlRegister.t2, 0); + elna_rtl_instruction_set_operand(result, 3, ElnaRtlOperand.immediate, 1, 0); + intermediate_instruction := next_instruction^; + intermediate_instruction^.next := result; + next_instruction^ := result; + result := operands + elsif instruction_kind = ElnaTacOperator.equal then + result := elna_rtl_binary_equality(tac_instruction, ElnaRtlOperator.seqz, next_instruction) + elsif instruction_kind = ElnaTacOperator.not_equal then + result := elna_rtl_binary_equality(tac_instruction, ElnaRtlOperator.snez, next_instruction) + elsif instruction_kind = ElnaTacOperator.negate then + result := elna_rtl_unary(tac_instruction, ElnaRtlOperator.neg, next_instruction) + elsif instruction_kind = ElnaTacOperator.complement then + result := elna_rtl_unary(tac_instruction, ElnaRtlOperator.not, next_instruction) + elsif instruction_kind = ElnaTacOperator.jump then + result := elna_rtl_instruction_create(ElnaRtlOperator.j); + elna_rtl_copy_operand(tac_instruction, 1, result) + 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.copy then + operand_type := _elna_tac_instruction_get_operand_type(tac_instruction, 1); + operand_value := _elna_tac_instruction_get_operand_value(tac_instruction, 1); + operand_length := _elna_tac_instruction_get_operand_length(tac_instruction, 1); + + if operand_type = ElnaTacOperand.pseudo then + operands := elna_rtl_load_operand_value(tac_instruction, 2, ElnaRtlRegister.t4); + result := operands; + operands := result^.next; + + next_instruction^ := elna_rtl_instruction_create(ElnaRtlOperator.move); + _elna_tac_instruction_set_operand(next_instruction^, 1, ElnaRtlOperand.pseudo, operand_value, operand_length); + _elna_tac_instruction_set_operand(next_instruction^, 2, ElnaRtlOperand.register, ElnaRtlRegister.t4, 0); + + if operands = nil then + result^.next := next_instruction^ + else + operands^.next := next_instruction^ + end + end + end; + if next_instruction^ = nil then + next_instruction^ := result; + end; + return result +end; + +proc elna_instruction_module_create(data: Word, code: Word); +var + result: ^ElnaInstructionModule; +begin + result := malloc(#size(ElnaInstructionModule)); + + result^.data := data; + result^.code := code; + + return result +end; + +proc elna_tac_label(counter: Word, length: Word); +var + result1: Word; +begin + result1 := _elna_tac_instruction_create(ElnaTacOperator.label); + + _elna_tac_instruction_set_operand(result1, 1, ElnaTacOperand.symbol, counter, length); + + return result1 +end; + +proc elna_riscv_instruction_name(instruction_kind: Word); +var + argument_count: Word; +begin + if instruction_kind = ElnaRtlOperator.li then + argument_count := 2; + _write_s("\tli", 3) + elsif instruction_kind = ElnaRtlOperator.la then + argument_count := 2; + _write_s("\tla", 3) + elsif instruction_kind = ElnaRtlOperator.add then + argument_count := 3; + _write_s("\tadd", 4) + elsif instruction_kind = ElnaRtlOperator.addi then + argument_count := 3; + _write_s("\taddi", 5) + elsif instruction_kind = ElnaRtlOperator.lw then + argument_count := 2; + _write_s("\tlw", 3) + elsif instruction_kind = ElnaRtlOperator.sw then + argument_count := 2; + _write_s("\tsw", 3) + elsif instruction_kind = ElnaRtlOperator.jal then + argument_count := 1; + _write_s("\tcall", 5) + elsif instruction_kind = ElnaRtlOperator.move then + argument_count := 2; + _write_s("\tmv", 3) + elsif instruction_kind = ElnaRtlOperator.sub then + argument_count := 3; + _write_s("\tsub", 4) + elsif instruction_kind = ElnaRtlOperator.mul then + argument_count := 3; + _write_s("\tmul", 4) + elsif instruction_kind = ElnaRtlOperator.div then + argument_count := 3; + _write_s("\tdiv", 4) + elsif instruction_kind = ElnaRtlOperator.rem then + argument_count := 3; + _write_s("\trem", 4) + elsif instruction_kind = ElnaRtlOperator._xor then + argument_count := 3; + _write_s("\txor", 4) + elsif instruction_kind = ElnaRtlOperator.xori then + argument_count := 3; + _write_s("\txori", 5) + elsif instruction_kind = ElnaRtlOperator._or then + argument_count := 3; + _write_s("\tor", 3) + elsif instruction_kind = ElnaRtlOperator.and then + argument_count := 3; + _write_s("\tand", 4) + elsif instruction_kind = ElnaRtlOperator.seqz then + argument_count := 2; + _write_s("\tseqz", 5) + elsif instruction_kind = ElnaRtlOperator.snez then + argument_count := 2; + _write_s("\tsnez", 5) + elsif instruction_kind = ElnaRtlOperator.slt then + argument_count := 3; + _write_s("\tslt", 4) + elsif instruction_kind = ElnaRtlOperator.neg then + argument_count := 2; + _write_s("\tneg", 4) + elsif instruction_kind = ElnaRtlOperator.not then + argument_count := 2; + _write_s("\tnot", 4) + 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) + end; + return argument_count +end; + +proc elna_riscv_register(register: Word); +begin + _write_c('x'); + _write_i(register - 1) +end; + +proc elna_riscv_operand(instruction: Word, n: Word); +var + operand_value: Word; + operand_length: Word; + operand_type: Word; +begin + operand_type := elna_rtl_instruction_get_operand_type(instruction, n); + operand_value := elna_rtl_instruction_get_operand_value(instruction, n); + operand_length := elna_rtl_instruction_get_operand_length(instruction, n); + + _write_c(' '); + if operand_type = ElnaRtlOperand.register then + elna_riscv_register(operand_value) + elsif operand_type = ElnaRtlOperand.offset then + _write_i(operand_length); + _write_c('('); + elna_riscv_register(operand_value); + _write_c(')') + elsif operand_type = ElnaRtlOperand.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 (* ElnaRtlOperand.immediate *) + _write_i(operand_value) + else + _write_s(operand_value, operand_length) + end +end; + +proc elna_alloc_variable(operand_value: Word, operand_length: Word); +var + pseudo_symbol1: Word; +begin + pseudo_symbol1 := _symbol_table_lookup(@variable_map, operand_value, operand_length); + if pseudo_symbol1 = nil then + _symbol_table_enter(@variable_map, operand_value, operand_length, temporary_variable_counter); + pseudo_symbol1 := temporary_variable_counter; + temporary_variable_counter := temporary_variable_counter + 4 + end; + return pseudo_symbol1 +end; + +(** + * If the first operand of an instruction is an operation target and expected + * to be a register, but is not a register, then this procedure rewrites it + * to a temporary register and preserves its value in the following instruction. + *) +proc elna_alloc_operation_target(instruction: ^ElnaInstructionList); +var + operand_type: Word; + operand_value: Word; + operand_length: Word; + pseudo_symbol: Word; + store_instruction: ^ElnaInstructionList; +begin + operand_type := elna_rtl_instruction_get_operand_type(instruction, 1); + operand_value := elna_rtl_instruction_get_operand_value(instruction, 1); + operand_length := elna_rtl_instruction_get_operand_length(instruction, 1); + + if operand_type = ElnaRtlOperand.pseudo then + store_instruction := elna_rtl_instruction_create(ElnaRtlOperator.sw); + store_instruction^.next := instruction^.next; + + pseudo_symbol := elna_alloc_variable(operand_value, operand_length); + elna_rtl_instruction_set_operand(store_instruction, 1, ElnaRtlOperand.register, ElnaRtlRegister.t0, 0); + elna_rtl_instruction_set_operand(store_instruction, 2, ElnaRtlOperand.offset, ElnaRtlRegister.sp, pseudo_symbol); + + instruction^.next := store_instruction; + elna_rtl_instruction_set_operand(instruction, 1, ElnaRtlOperand.register, ElnaRtlRegister.t0, 0) + end +end; + +proc elna_alloc_load_address(instruction: ^ElnaInstructionList); +var + operand_type: Word; + operand_value: Word; + operand_length: Word; + pseudo_symbol: Word; +begin + operand_type := elna_rtl_instruction_get_operand_type(instruction, 2); + operand_value := elna_rtl_instruction_get_operand_value(instruction, 2); + operand_length := elna_rtl_instruction_get_operand_length(instruction, 2); + + if operand_type = ElnaRtlOperand.pseudo then + pseudo_symbol := elna_alloc_variable(operand_value, operand_length); + elna_rtl_instruction_set_kind(instruction, ElnaRtlOperator.addi); + + elna_rtl_instruction_set_operand(instruction, 2, ElnaRtlOperand.register, ElnaRtlRegister.sp, 0); + elna_rtl_instruction_set_operand(instruction, 3, ElnaRtlOperand.immediate, pseudo_symbol, 0) + end; + operand_type := elna_rtl_instruction_get_operand_type(instruction, 1); + + if operand_type = ElnaRtlOperand.pseudo then + elna_alloc_operation_target(instruction) + end +end; + +proc elna_alloc_store(instruction: ^ElnaInstructionList); +var + old_instruction: ^ElnaInstructionList; + operand_type: Word; + operand_value: Word; + operand_length: Word; + pseudo_symbol: Word; +begin + operand_type := elna_rtl_instruction_get_operand_type(instruction, 2); + operand_value := elna_rtl_instruction_get_operand_value(instruction, 2); + operand_length := elna_rtl_instruction_get_operand_length(instruction, 2); + + if operand_type = ElnaRtlOperand.pseudo then + old_instruction := malloc(elna_rtl_instruction_size()); + memcpy(old_instruction, instruction, elna_rtl_instruction_size()); + + pseudo_symbol := elna_alloc_variable(operand_value, operand_length); + elna_rtl_instruction_set_kind(instruction, ElnaRtlOperator.lw); + + elna_rtl_instruction_set_operand(instruction, 1, ElnaRtlOperand.register, ElnaRtlRegister.t1, 0); + elna_rtl_instruction_set_operand(instruction, 2, ElnaRtlOperand.offset, ElnaRtlRegister.sp, pseudo_symbol); + + instruction^.next := old_instruction; + elna_rtl_instruction_set_operand(old_instruction, 2, ElnaRtlOperand.offset, ElnaRtlRegister.t1, 0) + end +end; + +proc elna_alloc_load(instruction: ^ElnaInstructionList); +var + old_instruction: ^ElnaInstructionList; + operand_type: Word; + operand_value: Word; + operand_length: Word; + pseudo_symbol: Word; +begin + operand_type := elna_rtl_instruction_get_operand_type(instruction, 1); + operand_value := elna_rtl_instruction_get_operand_value(instruction, 1); + operand_length := elna_rtl_instruction_get_operand_length(instruction, 1); + + if operand_type = ElnaRtlOperand.pseudo then + old_instruction := malloc(elna_rtl_instruction_size()); + memcpy(old_instruction, instruction, elna_rtl_instruction_size()); + + pseudo_symbol := elna_alloc_variable(operand_value, operand_length); + elna_rtl_instruction_set_kind(old_instruction, ElnaRtlOperator.sw); + + elna_rtl_instruction_set_operand(old_instruction, 1, ElnaRtlOperand.register, ElnaRtlRegister.t1, 0); + elna_rtl_instruction_set_operand(old_instruction, 2, ElnaRtlOperand.offset, ElnaRtlRegister.sp, pseudo_symbol); + + instruction^.next := old_instruction; + elna_rtl_instruction_set_operand(instruction, 1, ElnaRtlOperand.register, ElnaRtlRegister.t1, 0) + end +end; + +proc elna_alloc_instruction(instruction: ^ElnaInstructionList); +var + instruction_kind: Word; + operand_type: Word; + operand_value: Word; + operand_length: Word; + pseudo_symbol: Word; + old_instruction: ^ElnaInstructionList; +begin + instruction_kind := elna_rtl_instruction_get_kind(instruction); + + if instruction_kind = ElnaRtlOperator.move then + operand_type := elna_rtl_instruction_get_operand_type(instruction, 1); + operand_value := elna_rtl_instruction_get_operand_value(instruction, 1); + operand_length := elna_rtl_instruction_get_operand_length(instruction, 1); + + if operand_type = ElnaRtlOperand.pseudo then + pseudo_symbol := elna_alloc_variable(operand_value, operand_length); + elna_rtl_instruction_set_kind(instruction, ElnaRtlOperator.sw); + + operand_type := elna_rtl_instruction_get_operand_type(instruction, 2); + operand_value := elna_rtl_instruction_get_operand_value(instruction, 2); + operand_length := elna_rtl_instruction_get_operand_length(instruction, 2); + + elna_rtl_instruction_set_operand(instruction, 1, operand_type, operand_value, operand_length); + elna_rtl_instruction_set_operand(instruction, 2, ElnaRtlOperand.offset, ElnaRtlRegister.sp, pseudo_symbol); + + goto elna_alloc_instruction_end + end; + + operand_type := elna_rtl_instruction_get_operand_type(instruction, 2); + operand_value := elna_rtl_instruction_get_operand_value(instruction, 2); + operand_length := elna_rtl_instruction_get_operand_length(instruction, 2); + + if operand_type = ElnaRtlOperand.pseudo then + pseudo_symbol := elna_alloc_variable(operand_value, operand_length); + elna_rtl_instruction_set_kind(instruction, ElnaRtlOperator.lw); + elna_rtl_instruction_set_operand(instruction, 2, ElnaRtlOperand.offset, ElnaRtlRegister.sp, pseudo_symbol); + + goto elna_alloc_instruction_end + end + elsif instruction_kind = ElnaRtlOperator.la then + elna_alloc_load_address(instruction) + elsif instruction_kind = ElnaRtlOperator.lw then + elna_alloc_load(instruction) + elsif instruction_kind = ElnaRtlOperator.sw then + elna_alloc_store(instruction) + elsif instruction_kind = ElnaRtlOperator._or then + elna_alloc_operation_target(instruction) + elsif instruction_kind = ElnaRtlOperator.and then + elna_alloc_operation_target(instruction) + elsif instruction_kind = ElnaRtlOperator.mul then + elna_alloc_operation_target(instruction) + elsif instruction_kind = ElnaRtlOperator.sub then + elna_alloc_operation_target(instruction) + elsif instruction_kind = ElnaRtlOperator.add then + elna_alloc_operation_target(instruction) + elsif instruction_kind = ElnaRtlOperator._xor then + elna_alloc_operation_target(instruction) + elsif instruction_kind = ElnaRtlOperator.rem then + elna_alloc_operation_target(instruction) + elsif instruction_kind = ElnaRtlOperator.slt then + elna_alloc_operation_target(instruction) + elsif instruction_kind = ElnaRtlOperator.beqz then + operand_type := elna_rtl_instruction_get_operand_type(instruction, 1); + operand_value := elna_rtl_instruction_get_operand_value(instruction, 1); + operand_length := elna_rtl_instruction_get_operand_length(instruction, 1); + + if operand_type = ElnaRtlOperand.pseudo then + old_instruction := malloc(elna_rtl_instruction_size()); + memcpy(old_instruction, instruction, elna_rtl_instruction_size()); + + pseudo_symbol := elna_alloc_variable(operand_value, operand_length); + elna_rtl_instruction_set_kind(instruction, ElnaRtlOperator.lw); + + elna_rtl_instruction_set_operand(instruction, 1, ElnaRtlOperand.register, ElnaRtlRegister.t0, 0); + elna_rtl_instruction_set_operand(instruction, 2, ElnaRtlOperand.offset, ElnaRtlRegister.sp, pseudo_symbol); + + instruction^.next := old_instruction; + elna_rtl_instruction_set_operand(old_instruction, 1, ElnaRtlOperand.register, ElnaRtlRegister.t0, 0); + + goto elna_alloc_instruction_end + end + elsif instruction_kind = ElnaRtlOperator.seqz then + elna_alloc_operation_target(instruction) + elsif instruction_kind = ElnaRtlOperator.snez then + elna_alloc_operation_target(instruction) + elsif instruction_kind = ElnaRtlOperator.xori then + elna_alloc_operation_target(instruction) + end; + .elna_alloc_instruction_end; +end; + +proc elna_riscv_instruction(instruction: Word); +var + argument_count: Word; + instruction_kind: Word; + current_argument: Word; + operand_value: Word; + operand_length: Word; +begin + instruction_kind := elna_rtl_instruction_get_kind(instruction); + argument_count := 0; + + if instruction_kind = ElnaRtlOperator.label then + operand_value := elna_rtl_instruction_get_operand_value(instruction, 1); + operand_length := elna_rtl_instruction_get_operand_length(instruction, 1); + _write_label(operand_value, operand_length); + _write_c(':') + elsif instruction_kind = ElnaRtlOperator.allocate_stack then + operand_value := elna_rtl_instruction_get_operand_value(instruction, 1); + + (* Write the prologue. *) + printf("\taddi sp, sp, -%i\n\tsw ra, %i(sp)\n\tsw s0, %i(sp)\n\taddi s0, sp, %i\n\0", + operand_value + 8, operand_value + 4, operand_value, operand_value + 8); + fflush(nil) + elsif instruction_kind = ElnaRtlOperator.ret then + operand_value := elna_rtl_instruction_get_operand_value(instruction, 1); + + (* Write the epilogue. *) + printf("\tlw ra, %i(sp)\n\tlw s0, %i(sp)\n\taddi sp, sp, %i\n\0", operand_value + 4, operand_value, operand_value + 8); + fflush(nil) + else + argument_count := elna_riscv_instruction_name(instruction_kind) + end; + current_argument := 1; + + .elna_riscv_instruction_loop; + if current_argument <= argument_count then + elna_riscv_operand(instruction, current_argument); + current_argument := current_argument + 1 + end; + if current_argument <= argument_count then + _write_c(','); + goto elna_riscv_instruction_loop + end; + + _write_c('\n') +end; + +proc elna_rtl_instructions(instruction: ^ElnaInstructionList); +var + last_copy1: ^ElnaInstructionList; + current_copy: ^ElnaInstructionList; + next_copy: ^ElnaInstructionList; + first_copy: ^ElnaInstructionList; +begin + if instruction <> nil then + first_copy := elna_rtl_instruction(instruction, @current_copy); + instruction := instruction^.next + else + first_copy := nil; + current_copy := nil + end; + .elna_rtl_instructions_start; + + if instruction <> nil then + next_copy := elna_rtl_instruction(instruction, @last_copy1); + + instruction := instruction^.next; + current_copy^.next := next_copy; + current_copy := last_copy1; + goto elna_rtl_instructions_start + end; + + return first_copy +end; + +proc elna_alloc_instructions(instruction: ^ElnaInstructionList); +begin + .elna_alloc_instructions_start; + + if instruction <> nil then + elna_alloc_instruction(instruction); + instruction := instruction^.next; + goto elna_alloc_instructions_start + end +end; + +proc elna_riscv_instructions(instruction: ^ElnaInstructionList); +begin + .elna_riscv_instructions_start; + if instruction <> nil then + elna_riscv_instruction(instruction); + instruction := instruction^.next; + goto elna_riscv_instructions_start + end +end; + +proc elna_alloc_procedure(rtl_declaration: ^ElnaInstructionDeclaration); +var + stack_instruction: ^ElnaInstructionList; +begin + .elna_alloc_procedure_loop; + temporary_variable_counter := 4; + variable_map := 0; + + elna_alloc_instructions(rtl_declaration^.body); + if rtl_declaration^.stack then + stack_instruction := elna_rtl_instruction_create(ElnaRtlOperator.allocate_stack); + stack_instruction^.next := rtl_declaration^.body; + elna_rtl_instruction_set_operand(stack_instruction, 1, ElnaRtlOperand.immediate, temporary_variable_counter, 0); + + rtl_declaration^.body := stack_instruction; + stack_instruction := elna_rtl_instruction_create(ElnaRtlOperator.ret); + elna_rtl_instruction_set_operand(stack_instruction, 1, ElnaRtlOperand.immediate, temporary_variable_counter, 0); + + elna_instruction_list_concatenate(rtl_declaration^.body, stack_instruction) + end; + + rtl_declaration := rtl_declaration^.next; + if rtl_declaration <> nil then + goto elna_alloc_procedure_loop + end +end; + +proc elna_riscv_procedure(procedure: ^ElnaInstructionDeclaration); +begin + .elna_riscv_procedure_loop; + + (* Write .type _procedure_name, @function. *) + _write_z(".type \0"); + + _write_s(procedure^.name, procedure^.length); + _write_z(", @function\n\0"); + + (* Write procedure label, _procedure_name: *) + _write_s(procedure^.name, procedure^.length); + _write_z(":\n\0"); + + elna_riscv_instructions(procedure^.body); + _write_z("\tret\n\0"); + + procedure := procedure^.next; + if procedure <> nil then + goto elna_riscv_procedure_loop + end +end; + +proc elna_riscv_variable(variable: ^ElnaInstructionDeclaration); +begin + .elna_riscv_variable_loop; + if variable <> 0 then + _write_z(".type \0"); + _write_s(variable^.name, variable^.length); + _write_z(", @object\n\0"); + + _write_s(variable^.name, variable^.length); + _write_c(':'); + + _write_z(" .zero \0"); + _write_i(variable^.body); + + _write_c('\n'); + variable := variable^.next; + + goto elna_riscv_variable_loop + end +end; + +proc elna_rtl_module_declaration(tac_module: ^ElnaInstructionModule); +var + code_part: Word; + data_part: Word; +begin + data_part := elna_rtl_globals(tac_module^.data); + code_part := elna_rtl_procedures(tac_module^.code); + + return elna_instruction_module_create(data_part, code_part) +end; + +proc elna_alloc_module(pair: ^ElnaInstructionModule); +begin + elna_alloc_procedure(pair^.code) +end; + +proc elna_riscv_module(pair: ^ElnaInstructionModule); +var + compiler_strings_copy: Word; + compiler_strings_end: Word; + current_byte: Word; +begin + _write_z(".globl main\n\n\0"); + _write_z(".section .data\n\0"); + + elna_riscv_variable(pair^.data); + + _write_z(".section .text\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"); + + elna_riscv_procedure(pair^.code); + + _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_riscv_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_riscv_module_loop + end; + _write_c('"'); + _write_c('\n'); +end; + +proc elna_parser_integer_literal(); +var + integer_token: Word; + integer_length: Word; + result: ^ElnaTreeIntegerLiteral; +begin + result := malloc(#size(ElnaTreeIntegerLiteral)); + + (* TODO: Convert the integer string to a number. *) + integer_token := _elna_lexer_global_get_start(); + integer_length := _elna_lexer_global_get_end(); + integer_length := integer_length - integer_token; + _elna_lexer_skip_token(); + + result^.kind := ElnaTreeKind.integer_literal; + result^.value := integer_token; + result^.length := integer_length; + result^.type_decoration := nil; + + return result +end; + +proc elna_parser_boolean_literal(); +var + boolean_token: Word; + result: ^ElnaTreeBooleanLiteral; +begin + result := malloc(#size(ElnaTreeBooleanLiteral)); + + boolean_token := _elna_lexer_global_get_start(); + _elna_lexer_skip_token(); + + result^.kind := ElnaTreeKind.boolean_literal; + result^.value := string_compare(boolean_token, 4, "true", 4); + result^.type_decoration := nil; + + return result +end; + +proc elna_parser_nil_literal(); +var + result: ^ElnaTreeNilLiteral; +begin + _elna_lexer_skip_token(); + + result := malloc(#size(ElnaTreeNilLiteral)); + result^.kind := ElnaTreeKind.null; + result^.type_decoration := nil; + + return result +end; + +proc elna_tac_integer_literal(integer_literal_node: ^ElnaTreeIntegerLiteral, operand_type: Word, operand_value: Word, operand_length: Word); +begin + operand_type^ := ElnaTacOperand.immediate; + operand_value^ := integer_literal_node^.value; + operand_length^ := integer_literal_node^.length; + + return nil +end; + +proc elna_tac_boolean_literal(boolean_literal_node: ^ElnaTreeBooleanLiteral, operand_type: Word, operand_value: Word, operand_length: Word); +begin + operand_type^ := ElnaTacOperand.immediate; + operand_value^ := boolean_literal_node^.value; + operand_length^ := 0; + + return nil +end; + +proc elna_tac_nil_literal(nil_node: Word, operand_type: Word, operand_value: Word, operand_length: Word); +begin + operand_type^ := ElnaTacOperand.immediate; + operand_value^ := 0; + operand_length^ := 0; + + return nil +end; + +proc elna_parser_character_literal(); +var + character: Word; + character_length: Word; + result: ^ElnaTreeIntegerLiteral; +begin + result := malloc(#size(ElnaTreeCharacterLiteral)); + + character := _elna_lexer_global_get_start(); + character_length := _elna_lexer_global_get_end(); + character_length := character_length - character; + _elna_lexer_skip_token(); + + result^.kind := ElnaTreeKind.character_literal; + result^.value := character; + result^.length := character_length; + result^.type_decoration := nil; + + return result +end; + +proc elna_tac_character_literal(character_literal_node: ^ElnaTreeCharacterLiteral, operand_type: Word, operand_value: Word, operand_length: Word); +begin + operand_type^ := ElnaTacOperand.immediate; + operand_value^ := character_literal_node^.value; + operand_length^ := character_literal_node^.length; + + return nil +end; + +proc elna_parser_variable_expression(); +var + name_pointer: Word; + name_length: Word; + result: ^ElnaTreeVariableExpression; +begin + name_pointer := _elna_lexer_global_get_start(); + name_length := _elna_lexer_global_get_end() - name_pointer; + _elna_lexer_skip_token(); + + result := malloc(#size(ElnaTreeVariableExpression)); + + result^.kind := ElnaTreeKind.variable_expression; + result^.name := name_pointer; + result^.length := name_length; + result^.type_decoration := nil; + + return result +end; + +proc elna_tac_variable_expression(variable_expression: ^ElnaTreeVariableExpression, symbol_table: Word, operand_type: Word, operand_value: Word, operand_length: Word); +var + lookup_result: ^ElnaSymbolTemporaryInfo; +begin + lookup_result := _symbol_table_lookup(symbol_table, variable_expression^.name, variable_expression^.length); + + if lookup_result <> nil then + operand_type^ := ElnaTacOperand.pseudo; + operand_value^ := variable_expression^.name; + operand_length^ := variable_expression^.length + else + operand_type^ := ElnaTacOperand.symbol; + operand_value^ := variable_expression^.name; + operand_length^ := variable_expression^.length + end; + return nil +end; + +proc elna_parser_string_literal(); +var + length: Word; + token_start: Word; + result: ^ElnaTreeStringLiteral; +begin + result := malloc(#size(ElnaTreeStringLiteral)); + + token_start := _elna_lexer_global_get_start(); + length := _string_length(token_start); + _elna_lexer_skip_token(); + + result^.kind := ElnaTreeKind.string_literal; + result^.value := token_start; + result^.length := length; + result^.type_decoration := nil; + + return result +end; + +proc _elna_tac_string_literal(string_literal_node: ^ElnaTreeStringLiteral, operand_type: Word, operand_value: Word, operand_length: Word); +var + offset: Word; + first_instruction: Word; + next_instruction: Word; +begin + offset := _add_string(string_literal_node^.value); + + first_instruction := _elna_tac_instruction_create(ElnaTacOperator.get_address); + _elna_tac_instruction_set_operand(first_instruction, 1, ElnaTacOperand.pseudo, "$unary", 6); + _elna_tac_instruction_set_operand(first_instruction, 2, ElnaTacOperand.symbol, "strings", 7); + + (* Add offset to the string block pointer. *) + next_instruction := _elna_tac_instruction_create(ElnaTacOperator.add); + _elna_tac_instruction_set_operand(next_instruction, 1, ElnaTacOperand.pseudo, "$unary", 6); + _elna_tac_instruction_set_operand(next_instruction, 2, ElnaTacOperand.pseudo, "$unary", 6); + _elna_tac_instruction_set_operand(next_instruction, 3, ElnaTacOperand.immediate, offset, 0); + + operand_type^ := ElnaTacOperand.pseudo; + operand_value^ := "$unary"; + operand_length^ := 6; + + return elna_instruction_list_concatenate(first_instruction, next_instruction) +end; + +proc elna_parser_trait_expression(); +var + result: ^ElnaTreeTraitExpression; + token_kind: Word; +begin + printf("# Comment\n\0"); + fflush(nil); + + result := malloc(#size(ElnaTreeTraitExpression)); + result^.kind := ElnaTreeKind.trait_expression; + + result^.name := _elna_lexer_global_get_start(); + result^.length := _elna_lexer_global_get_end() - result^.name; + + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + result^.argument := elna_parser_type_expression(); + + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + return result +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.boolean then + parser_node := elna_parser_boolean_literal() + elsif token_kind = ElnaLexerKind.null then + parser_node := elna_parser_nil_literal() + elsif token_kind = ElnaLexerKind.trait then + parser_node := elna_parser_trait_expression() + 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: ^ElnaTreeDereferenceExpression; +begin + result := malloc(#size(ElnaTreeDereferenceExpression)); + + result^.kind := ElnaTreeKind.dereference_expression; + result^.pointer := simple_expression; + result^.type_decoration := nil; + _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_parser_designator_loop; + _elna_lexer_read_token(@token_kind); + + if token_kind = ElnaLexerKind.hat then + simple_expression := elna_parser_dereference_expression(simple_expression); + goto elna_parser_designator_loop + elsif token_kind = ElnaLexerKind.dot then + simple_expression := elna_parser_field_access_expression(simple_expression); + goto elna_parser_designator_loop + elsif token_kind = ElnaLexerKind.left_paren then + simple_expression := elna_parser_call(simple_expression); + goto elna_parser_designator_loop + end; + return simple_expression +end; + +proc elna_tac_trait_expression(trait_node: ^ElnaTreeTraitExpression, operand_type: Word, operand_value: Word, operand_length: Word); +var + symbol: ^ElnaSymbolTypeInfo; + info_type: ^ElnaType; + parser_node: ^ElnaTreeNamedTypeExpression; +begin + parser_node := trait_node^.argument; + symbol := _symbol_table_lookup(@symbol_table_global, parser_node^.name, parser_node^.length); + info_type := symbol^._type; + + operand_type^ := ElnaTacOperand.immediate; + operand_value^ := info_type^.size; + operand_length^ := 0; + + return nil +end; + +proc elna_tac_simple_expression(parser_node: ^ElnaTreeNode, symbol_table: Word, operand_type: Word, operand_value: Word, operand_length: Word); +var + instruction: Word; +begin + if parser_node^.kind = ElnaTreeKind.character_literal then + instruction := elna_tac_character_literal(parser_node, operand_type, operand_value, operand_length) + elsif parser_node^.kind = ElnaTreeKind.string_literal then + instruction := _elna_tac_string_literal(parser_node, operand_type, operand_value, operand_length) + elsif parser_node^.kind = ElnaTreeKind.integer_literal then + instruction := elna_tac_integer_literal(parser_node, operand_type, operand_value, operand_length) + elsif parser_node^.kind = ElnaTreeKind.boolean_literal then + instruction := elna_tac_boolean_literal(parser_node, operand_type, operand_value, operand_length) + elsif parser_node^.kind = ElnaTreeKind.null then + instruction := elna_tac_nil_literal(parser_node, operand_type, operand_value, operand_length) + elsif parser_node^.kind = ElnaTreeKind.trait_expression then + instruction := elna_tac_trait_expression(parser_node, operand_type, operand_value, operand_length) + else + instruction := elna_tac_variable_expression(parser_node, symbol_table, operand_type, operand_value, operand_length) + end; + return instruction +end; + +proc elna_parser_unary_expression(); +var + token_kind: Word; + result: ^ElnaTreeUnaryExpression; + 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; + result := malloc(#size(ElnaTreeUnaryExpression)); + + result^.kind := ElnaTreeKind.unary_expression; + result^.operand := operand; + result^.operator := operator; + result^.type_decoration := nil + end; + + return result +end; + +proc elna_tac_unary_expression(parser_node: ^ElnaTreeUnaryExpression, symbol_table: Word, operand_type: Word, operand_value: Word, operand_length: Word); +var + token_kind: Word; + operator: Word; + operand: ^ElnaTreeExpression; + is_address: Word; + first_instruction: Word; + instruction: Word; +begin + instruction := nil; + if parser_node^.kind = ElnaTreeKind.unary_expression then + operator := parser_node^.operator; + operand := parser_node^.operand + else + operator := 0; + operand := parser_node + end; + first_instruction := elna_tac_designator(operand, symbol_table, @is_address, operand_type, operand_value, operand_length); + + if operator = '@' then + instruction := _elna_tac_instruction_create(ElnaTacOperator.get_address); + _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.pseudo, "$unary", 6); + _elna_tac_instruction_set_operand(instruction, 2, operand_type^, operand_value^, operand_length^); + + operand_type^ := ElnaTacOperand.pseudo; + operand_value^ := "$unary"; + operand_length^ := 6 + elsif operator = '-' then + instruction := _elna_tac_instruction_create(ElnaTacOperator.negate); + _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.pseudo, "$unary", 6); + _elna_tac_instruction_set_operand(instruction, 2, operand_type^, operand_value^, operand_length^); + + operand_type^ := ElnaTacOperand.pseudo; + operand_value^ := "$unary"; + operand_length^ := 6 + elsif operator = '~' then + instruction := _elna_tac_instruction_create(ElnaTacOperator.complement); + _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.pseudo, "$unary", 6); + _elna_tac_instruction_set_operand(instruction, 2, operand_type^, operand_value^, operand_length^); + + operand_type^ := ElnaTacOperand.pseudo; + operand_value^ := "$unary"; + operand_length^ := 6 + elsif is_address then + instruction := _elna_tac_instruction_create(ElnaTacOperator.load); + _elna_tac_instruction_set_operand(instruction, 1, operand_type^, operand_value^, operand_length^); + _elna_tac_instruction_set_operand(instruction, 2, ElnaTacOperand.pseudo, "$unary", 6); + + operand_type^ := ElnaTacOperand.pseudo; + operand_value^ := "$unary"; + operand_length^ := 6 + else + instruction := _elna_tac_instruction_create(ElnaTacOperator.copy); + _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.pseudo, "$unary", 6); + _elna_tac_instruction_set_operand(instruction, 2, operand_type^, operand_value^, operand_length^); + + operand_type^ := ElnaTacOperand.pseudo; + operand_value^ := "$unary"; + operand_length^ := 6 + end; + return elna_instruction_list_concatenate(first_instruction, instruction) +end; + +proc elna_parser_binary_expression(); +var + lhs_node: Word; + rhs_node: Word; + token_kind: Word; + result: ^ElnaTreeBinaryExpression; +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 + result := malloc(#size(ElnaTreeBinaryExpression)); + + result^.kind := ElnaTreeKind.binary_expression; + result^.lhs := lhs_node; + result^.rhs := rhs_node; + result^.operator := token_kind; + result^.type_decoration := nil + else + result := lhs_node + end; + return result +end; + +proc elna_tac_binary_expression(parser_node: ^ElnaTreeBinaryExpression, symbol_table: Word, operand_type: Word, operand_value: Word, operand_length: Word); +var + first_instruction: Word; + instruction: Word; + current_instruction: Word; + lhs_type: Word; + lhs_value: Word; + lhs_length: Word; +begin + if parser_node^.kind <> ElnaTreeKind.binary_expression then + first_instruction := elna_tac_unary_expression(parser_node, symbol_table, operand_type, operand_value, operand_length) + else + lhs_type := 0; + lhs_value := 0; + lhs_length := 0; + first_instruction := elna_tac_unary_expression(parser_node^.lhs, symbol_table, @lhs_type, @lhs_value, @lhs_length); + + (* Save the value of the left expression on the stack. *) + instruction := _elna_tac_instruction_create(ElnaTacOperator.copy); + _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.pseudo, "$lhs", 4); + _elna_tac_instruction_set_operand(instruction, 2, lhs_type, lhs_value, lhs_length); + + if first_instruction = 0 then + first_instruction := instruction + else + elna_instruction_list_concatenate(first_instruction, instruction) + end; + current_instruction := instruction; + + lhs_type := 0; + lhs_value := 0; + lhs_length := 0; + instruction := elna_tac_unary_expression(parser_node^.rhs, symbol_table, @lhs_type, @lhs_value, @lhs_length); + current_instruction := elna_instruction_list_concatenate(current_instruction, instruction); + + if parser_node^.operator = ElnaLexerKind.plus then + instruction := _elna_tac_instruction_create(ElnaTacOperator.add) + elsif parser_node^.operator = ElnaLexerKind.minus then + instruction := _elna_tac_instruction_create(ElnaTacOperator.subtract) + elsif parser_node^.operator = ElnaLexerKind.multiplication then + instruction := _elna_tac_instruction_create(ElnaTacOperator.multiply) + elsif parser_node^.operator = ElnaLexerKind.and then + instruction := _elna_tac_instruction_create(ElnaTacOperator.and) + elsif parser_node^.operator = ElnaLexerKind._or then + instruction := _elna_tac_instruction_create(ElnaTacOperator._or) + elsif parser_node^.operator = ElnaLexerKind._xor then + instruction := _elna_tac_instruction_create(ElnaTacOperator._xor) + elsif parser_node^.operator = ElnaLexerKind.equals then + instruction := _elna_tac_instruction_create(ElnaTacOperator.equal) + elsif parser_node^.operator = ElnaLexerKind.remainder then + instruction := _elna_tac_instruction_create(ElnaTacOperator.remainder) + elsif parser_node^.operator = ElnaLexerKind.division then + instruction := _elna_tac_instruction_create(ElnaTacOperator.divide) + elsif parser_node^.operator = ElnaLexerKind.less_than then + instruction := _elna_tac_instruction_create(ElnaTacOperator.less_than) + elsif parser_node^.operator = ElnaLexerKind.greater_than then + instruction := _elna_tac_instruction_create(ElnaTacOperator.greater_than) + elsif parser_node^.operator = ElnaLexerKind.less_equal then + instruction := _elna_tac_instruction_create(ElnaTacOperator.less_or_equal) + elsif parser_node^.operator = ElnaLexerKind.greater_equal then + instruction := _elna_tac_instruction_create(ElnaTacOperator.greater_or_equal) + elsif parser_node^.operator = ElnaLexerKind.not_equal then + instruction := _elna_tac_instruction_create(ElnaTacOperator.not_equal) + end; + _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.pseudo, "$binary", 7); + _elna_tac_instruction_set_operand(instruction, 2, ElnaTacOperand.pseudo, "$lhs", 4); + _elna_tac_instruction_set_operand(instruction, 3, lhs_type, lhs_value, lhs_length); + + operand_type^ := ElnaTacOperand.pseudo; + operand_value^ := "$binary"; + operand_length^ := 7; + + elna_instruction_list_concatenate(current_instruction, instruction) + 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: ^ElnaTreeStatement; + argument_number: Word; + token_kind: Word; +begin + result := malloc(_call_size()); + result^.kind := ElnaTreeKind.call; + result^.next := nil; + + 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, nil); + + return result +end; + +proc elna_tac_call(parsed_call: Word, symbol_table: Word); +var + argument_count: Word; + name_length: Word; + name: Word; + parsed_expression: ^ElnaTreeVariableExpression; + instruction: Word; + first_instruction: Word; + current_instruction: Word; + operand_type: Word; + operand_value: Word; + operand_length: Word; + arguments_operand: Word; + call_instruction: Word; + name_buffer: Word; +begin + parsed_expression := _call_get_name(parsed_call); + name := parsed_expression^.name; + name_length := parsed_expression^.length; + argument_count := 0; + first_instruction := 0; + + .elna_tac_call_count; + parsed_expression := _call_get_argument(parsed_call, argument_count + 1); + + if parsed_expression <> nil ten + argument_count := argument_count + 1; + goto elna_tac_call_count + end; + arguments_operand := malloc(argument_count * 12); + + call_instruction := _elna_tac_instruction_create(ElnaTacOperator.proc_call); + _elna_tac_instruction_set_operand(call_instruction, 1, ElnaTacOperand.symbol, name, name_length); + _elna_tac_instruction_set_operand(call_instruction, 2, ElnaTacOperand.list, arguments_operand, argument_count); + + argument_count := 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 + operand_type := 0; + operand_value := 0; + operand_length := 0; + instruction := elna_tac_binary_expression(parsed_expression, symbol_table, @operand_type, @operand_value, @operand_length); + if first_instruction = 0 then + first_instruction := instruction + else + elna_instruction_list_concatenate(current_instruction, instruction) + end; + if instruction <> 0 then + current_instruction := instruction + end; + + (* Save the argument on the stack. *) + name_buffer := malloc(4); + sprintf(name_buffer, "$ar%i\0", argument_count); + instruction := _elna_tac_instruction_create(ElnaTacOperator.copy); + _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.pseudo, name_buffer, 4); + _elna_tac_instruction_set_operand(instruction, 2, operand_type, operand_value, operand_length); + if first_instruction = 0 then + first_instruction := instruction + else + elna_instruction_list_concatenate(current_instruction, instruction) + end; + current_instruction := instruction; + + arguments_operand^ := ElnaTacOperand.pseudo; + arguments_operand := arguments_operand + 4; + arguments_operand^ := name_buffer; + arguments_operand := arguments_operand + 4; + arguments_operand^ := 4; + arguments_operand := arguments_operand + 4; + + argument_count := argument_count + 1; + goto elna_tac_call_loop + end; + .elna_tac_call_finalize; + + if first_instruction = nil then + first_instruction := call_instruction + else + elna_instruction_list_concatenate(current_instruction, call_instruction) + end; + return first_instruction +end; + +proc elna_parser_goto_statement(); +var + token_kind: Word; + result: ^ElnaTreeGotoStatement; +begin + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + + result := malloc(#size(ElnaTreeGotoStatement)); + result^.kind := ElnaTreeKind.goto_statement; + result^.next := nil; + result^.label := _elna_lexer_global_get_start(); + result^.length := _elna_lexer_global_get_end() - result^.label; + + _elna_lexer_skip_token(); + + return result +end; + +proc elna_tac_goto_statement(parser_node: ^ElnaTreeGotoStatement); +var + label_length1: Word; + label_with_dot1: Word; + instruction1: Word; +begin + label_length1 := parser_node^.length + 1; + label_with_dot1 := malloc(label_length1); + + _store_byte('.', label_with_dot1); + memcpy(label_with_dot1 + 1, parser_node^.label, parser_node^.length); + + instruction1 := _elna_tac_instruction_create(ElnaTacOperator.jump); + _elna_tac_instruction_set_operand(instruction1, 1, ElnaTacOperand.symbol, label_with_dot1, label_length1); + return instruction1 +end; + +proc elna_parser_label_declaration(); +var + token_kind: Word; + label_name: Word; + label_length: Word; + result: ^ElnaTreeGotoStatement; +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(); + + result := malloc(#size(ElnaTreeLabelDeclaration)); + + result^.kind := ElnaTreeKind.label_declaration; + result^.next := nil; + result^.label := label_name; + result^.length := label_length; + + return result +end; + +proc elna_tac_label_declaration(parser_node: ^ElnaTreeLabelDeclaration); + return elna_tac_label(parser_node^.label, parser_node^.length) +end; + +proc elna_tac_enumeration_value(field_access_expression: ^ElnaTreeFieldAccessExpression, operand_type: Word, operand_value: Word, operand_length: Word); +var + enumeration_type: ^ElnaTypeEnumeration; + members: Word; + members_length: Word; + token_type: Word; + symbol_info: ^ElnaSymbolTypeInfo; + member_name: Word; + member_length: Word; + counter: Word; + enumeration_type_name: ^ElnaTreeVariableExpression; +begin + enumeration_type_name := field_access_expression^.aggregate; + symbol_info := _symbol_table_lookup(@symbol_table_global, enumeration_type_name^.name, enumeration_type_name^.length); + + enumeration_type := symbol_info^._type; + members := enumeration_type^.members; + members_length := enumeration_type^.length; + + _elna_lexer_read_token(@token_type); + counter := 1; + + .elna_tac_enumeration_value_members; + if members_length > 0 then + member_name := members^; + member_length := members + 4; + member_length := member_length^; + + if string_compare(field_access_expression^.field, field_access_expression^.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; + (* Found. *) + operand_type^ := ElnaTacOperand.immediate; + operand_value^ := counter; + operand_length^ := 0 + end; + return nil +end; + +proc elna_parser_field_access_expression(aggregate: Word); +var + token_kind: Word; + result: ^ElnaTreeFieldAccessExpression; +begin + (* Skip dot. Read the enumeration value. *) + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + + result := malloc(#size(ElnaTreeFieldAccessExpression)); + + result^.kind := ElnaTreeKind.field_access_expression; + result^.type_decoration := nil; + result^.aggregate := aggregate; + result^.field := _elna_lexer_global_get_start(); + result^.length := _elna_lexer_global_get_end() - result^.field; + + _elna_lexer_skip_token(); + + return result +end; + +proc elna_tac_designator(parser_node: ^ElnaTreeExpression, symbol_table: Word, is_address: Word, operand_type: Word, operand_value: Word, operand_length: Word); +var + field_access_expression: ^ElnaTreeFieldAccessExpression; + dereference_expression: ^ElnaTreeDereferenceExpression; + expression_type: ^ElnaType; + first_instruction: Word; + last_instruction: Word; + designator_base: ^ElnaTreeExpression; + aggregate_type: ^ElnaTypeRecord; + field_count: Word; + current_field: ^ElnaTypeField; + field_offset: Word; +begin + if parser_node^.kind = ElnaTreeKind.dereference_expression then + dereference_expression := parser_node; + first_instruction := elna_tac_designator(dereference_expression^.pointer, symbol_table, is_address, operand_type, operand_value, operand_length); + is_address^ := 1 + elsif parser_node^.kind = ElnaTreeKind.field_access_expression then + field_access_expression := parser_node; + expression_type := field_access_expression^.type_decoration; + + if expression_type^.kind = ElnaTypeKind.enumeration then + first_instruction := elna_tac_enumeration_value(field_access_expression, operand_type, operand_value, operand_length); + is_address^ := 0 + else + designator_base := field_access_expression^.aggregate; + first_instruction := elna_tac_designator(designator_base, symbol_table, is_address, operand_type, operand_value, operand_length); + aggregate_type := designator_base^.type_decoration; + + field_count := aggregate_type^.length; + current_field := aggregate_type^.members; + field_offset := 0; + + .elna_tac_designator_field; + + if string_compare(field_access_expression^.field, field_access_expression^.length, current_field^.name, current_field^.length) = 0 then + field_count := field_count - 1; + current_field := current_field + #size(ElnaTypeField); + field_offset := field_offset + 4; + goto elna_tac_designator_field + end; + last_instruction := _elna_tac_instruction_create(ElnaTacOperator.add); + _elna_tac_instruction_set_operand(last_instruction, 1, ElnaTacOperand.pseudo, "$unary", 6); + _elna_tac_instruction_set_operand(last_instruction, 2, ElnaTacOperand.immediate, field_offset, 0); + _elna_tac_instruction_set_operand(last_instruction, 3, operand_type^, operand_value^, operand_length^); + + operand_type^ := ElnaTacOperand.pseudo; + operand_value^ := "$unary"; + operand_length^ := 6; + + is_address^ := 1; + first_instruction := elna_instruction_list_concatenate(first_instruction, last_instruction) + end; + elsif parser_node^.kind = ElnaTreeKind.call then + first_instruction := elna_tac_call(parser_node, symbol_table); + + operand_type^ := ElnaTacOperand.temporary; + operand_value^ := 11; + operand_length^ := 0; + is_address^ := 0 + else + first_instruction := elna_tac_simple_expression(parser_node, symbol_table, operand_type, operand_value, operand_length); + is_address^ := 0 + end; + return first_instruction +end; + +proc elna_parser_assign_statement(assignee: Word); +var + result: ^ElnaTreeAssignStatement; + token_kind: Word; +begin + result := malloc(#size(ElnaTreeAssignStatement)); + + result^.kind := ElnaTreeKind.assign_statement; + result^.next := nil; + result^.assignee := assignee; + + (* Skip the assignment sign (:=) with surrounding whitespaces. *) + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + result^.assignment := elna_parser_binary_expression(); + + return result +end; + +proc elna_tac_assign_statement(parser_tree: ^ElnaTreeAssignStatement, symbol_table: Word); +var + is_address: Word; + first_instruction: Word; + instruction: Word; + current_instruction: Word; + operand_type: Word; + operand_value: Word; + operand_length: Word; +begin + operand_type := 0; + operand_value := 0; + operand_length := 0; + first_instruction := elna_tac_designator(parser_tree^.assignee, symbol_table, @is_address, @operand_type, @operand_value, @operand_length); + + if operand_type = ElnaTacOperand.pseudo then + if is_address then + (* Save the assignee address on the stack. *) + current_instruction := _elna_tac_instruction_create(ElnaTacOperator.copy); + _elna_tac_instruction_set_operand(current_instruction, 1, ElnaTacOperand.pseudo, "$assign", 7); + _elna_tac_instruction_set_operand(current_instruction, 2, operand_type, operand_value, operand_length); + first_instruction := elna_instruction_list_concatenate(first_instruction, current_instruction); + + (* Compile the assignment. *) + operand_type := 0; + operand_value := 0; + operand_length := 0; + instruction := elna_tac_binary_expression(parser_tree^.assignment, symbol_table, @operand_type, @operand_value, @operand_length); + + if instruction <> 0 then + elna_instruction_list_concatenate(current_instruction, instruction); + current_instruction := instruction + end; + + 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.pseudo, "$assign", 7); + + elna_instruction_list_concatenate(current_instruction, instruction) + else + current_instruction := _elna_tac_instruction_create(ElnaTacOperator.copy); + _elna_tac_instruction_set_operand(current_instruction, 1, operand_type, operand_value, operand_length); + + operand_type := 0; + operand_value := 0; + operand_length := 0; + instruction := elna_tac_binary_expression(parser_tree^.assignment, symbol_table, @operand_type, @operand_value, @operand_length); + _elna_tac_instruction_set_operand(current_instruction, 2, operand_type, operand_value, operand_length); + + first_instruction := elna_instruction_list_concatenate(instruction, current_instruction) + end + else + (* Save the assignee address on the stack. *) + current_instruction := _elna_tac_instruction_create(ElnaTacOperator.get_address); + _elna_tac_instruction_set_operand(current_instruction, 1, ElnaTacOperand.pseudo, "$assign", 7); + _elna_tac_instruction_set_operand(current_instruction, 2, operand_type, operand_value, operand_length); + first_instruction := elna_instruction_list_concatenate(first_instruction, current_instruction); + + (* Compile the assignment. *) + operand_type := 0; + operand_value := 0; + operand_length := 0; + instruction := elna_tac_binary_expression(parser_tree^.assignment, symbol_table, @operand_type, @operand_value, @operand_length); + + if instruction <> 0 then + elna_instruction_list_concatenate(current_instruction, instruction); + current_instruction := instruction + end; + + 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.pseudo, "$assign", 7); + + elna_instruction_list_concatenate(current_instruction, instruction) + end; + return first_instruction +end; + +proc elna_parser_return_statement(); +var + token_kind: Word; + returned: Word; + label_length: Word; + result: ^ElnaTreeReturnStatement; +begin + (* Skip "return" keyword and whitespace after it. *) + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + + returned := elna_parser_binary_expression(); + result := malloc(#size(ElnaTreeReturnStatement)); + + result^.kind := ElnaTreeKind.return_statement; + result^.next := nil; + result^.returned := returned; + + return result +end; + +proc elna_tac_return_statement(parser_node: ^ElnaTreeReturnStatement, symbol_table: Word); +var + first_instruction: Word; + instruction: Word; + operand_type: Word; + operand_value: Word; + operand_length: Word; +begin + operand_type := 0; + operand_value := 0; + operand_length := 0; + first_instruction := elna_tac_binary_expression(parser_node^.returned, symbol_table, @operand_type, @operand_value, @operand_length); + + 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) +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 + token_kind: Word; + result: ^ElnaTreeConditionalStatements; +begin + result := malloc(#size(ElnaTreeConditionalStatements)); + + (* Skip "if", "while" or "elsif". *) + _elna_lexer_skip_token(); + result^.condition := elna_parser_binary_expression(); + + (* Skip "then" or "do". *) + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + result^.statements := elna_parser_statements(); + result^.next := nil; + + return result +end; + +proc elna_tac_conditional_statements(parser_node: ^ElnaTreeConditionalStatements, after_end_label: Word, symbol_table: Word); +var + condition_label: Word; + instruction: Word; + current_instruction: Word; + first_instruction: Word; + operand_type: Word; + operand_value: Word; + operand_length: Word; +begin + (* Compile condition. *) + operand_type := 0; + operand_value := 0; + operand_length := 0; + first_instruction := elna_tac_binary_expression(parser_node^.condition, symbol_table, @operand_type, @operand_value, @operand_length); + + (* 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_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); + + elna_instruction_list_concatenate(first_instruction, current_instruction); + + instruction := elna_tac_statements(parser_node^.statements, symbol_table); + if instruction <> 0 then + elna_instruction_list_concatenate(current_instruction, instruction); + current_instruction := instruction + end; + + instruction := _elna_tac_instruction_create(ElnaTacOperator.jump); + _elna_tac_instruction_set_operand(instruction, 1, ElnaTacOperand.symbol, after_end_label, 0); + elna_instruction_list_concatenate(current_instruction, instruction); + + current_instruction := elna_tac_label(condition_label, 0); + elna_instruction_list_concatenate(instruction, current_instruction); + + return first_instruction +end; + +proc elna_parser_if_statement(); +var + result: ^ElnaTreeIfStatement; + token_kind: Word; + previous_conditional: ^ElnaTreeConditionalStatements; + next_conditional: ^ElnaTreeConditionalStatements; +begin + result := malloc(#size(ElnaTreeIfStatement)); + + result^.kind := ElnaTreeKind.if_statement; + result^.next := nil; + + previous_conditional := elna_parser_conditional_statements(); + result^.conditionals := 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(); + previous_conditional^.next := next_conditional; + previous_conditional = next_conditional; + + goto elna_parser_if_statement_loop + elsif token_kind = ElnaLexerKind._else then + _elna_lexer_skip_token(); + result^._else := elna_parser_statements() + else + result^._else := nil + end; + _elna_lexer_skip_token(); + + return result +end; + +proc elna_parser_statement(); +var + token_kind: Word; + result : ^ElnaTreeNode; +begin + result := nil; + _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 result^.kind <> ElnaTreeKind.call then + result := elna_parser_assign_statement(result) + end + end; + return result +end; + +proc elna_parser_statements(); +var + token_kind: Word; + previous_statement: ^ElnaTreeStatement; + next_statement: ^ElnaTreeStatement; + first_statement: ^ElnaTreeStatement; +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(); + previous_statement^.next := 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: ^ElnaTreeStatement; + instruction: Word; + first_instruction: Word; + current_instruction: Word; +begin + current_statement := parser_node; + first_instruction := nil; + + .elna_tac_statements_loop; + if current_statement <> nil then + instruction := elna_tac_statement(current_statement, symbol_table); + current_statement := current_statement^.next; + if instruction = 0 then + goto elna_tac_statements_loop + end; + if first_instruction = nil then + first_instruction := instruction + else + elna_instruction_list_concatenate(current_instruction, instruction) + end; + current_instruction := instruction; + goto elna_tac_statements_loop + end; + return first_instruction +end; + +proc elna_tac_if_statement(parser_node: ^ElnaTreeIfStatement, symbol_table: Word); +var + current_node: ^ElnaTreeConditionalStatements; + 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 := parser_node^.conditionals; + first_instruction := elna_tac_conditional_statements(current_node, after_end_label, symbol_table); + current_instruction := first_instruction; + + .elna_tac_if_statement_loop; + current_node := current_node^.next; + if current_node <> nil then + instruction := elna_tac_conditional_statements(current_node, after_end_label, symbol_table); + elna_instruction_list_concatenate(current_instruction, instruction); + current_instruction := instruction; + goto elna_tac_if_statement_loop + end; + current_node := parser_node^._else; + + if parser_node^._else <> nil then + instruction := elna_tac_statements(parser_node^._else, symbol_table); + if instruction <> 0 then + elna_instruction_list_concatenate(current_instruction, instruction); + current_instruction := instruction + end + end; + instruction := elna_tac_label(after_end_label, 0); + elna_instruction_list_concatenate(current_instruction, instruction); + + return first_instruction +end; + +proc elna_tac_statement(parser_node: ^ElnaTreeNode, symbol_table: Word); +var + instruction: Word; +begin + if parser_node^.kind = ElnaTreeKind.goto_statement then + instruction := elna_tac_goto_statement(parser_node) + elsif parser_node^.kind = ElnaTreeKind.if_statement then + instruction := elna_tac_if_statement(parser_node, symbol_table) + elsif parser_node^.kind = ElnaTreeKind.return_statement then + instruction := elna_tac_return_statement(parser_node, symbol_table) + elsif parser_node^.kind = ElnaTreeKind.label_declaration then + instruction := elna_tac_label_declaration(parser_node) + elsif parser_node^.kind = ElnaTreeKind.call then + instruction := elna_tac_call(parser_node, symbol_table) + elsif parser_node^.kind = ElnaTreeKind.assign_statement then + instruction := elna_tac_assign_statement(parser_node, symbol_table) + else + instruction := nil + 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; + result: ^ElnaTreeEnumerationTypeExpression; + 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 := malloc(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(); + + result := malloc(#size(ElnaTreeEnumerationTypeExpression)); + + result^.kind := ElnaTreeKind.record_type_expression; + result^.members := memory_start; + result^.length := 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: ^ElnaTreeEnumerationTypeExpression; + 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 := malloc(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(); + + result := malloc(#size(ElnaTreeEnumerationTypeExpression)); + + result^.kind := ElnaTreeKind.enumeration_type_expression; + result^.members := memory_start; + result^.length := 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_enumeration_type_expression(parser_node: ^ElnaTreeEnumerationTypeExpression); +var + result: ^ElnaTypeEnumeration; + memory_start: Word; + member_count: Word; + member_array_start: Word; + member_array_current: Word; +begin + result := malloc(#size(ElnaTypeEnumeration)); + + memory_start := parser_node^.members; + member_count := parser_node^.length; + + (* Copy the list of enumeration members into an array of strings. *) + member_array_start := malloc(member_count * 8); + 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 := parser_node^.length; + + result^.kind := ElnaTypeKind.enumeration; + result^.size := 4; + result^.members := member_array_start; + result^.length := member_count; + + return result +end; + +proc elna_name_pointer_type_expression(parser_node: ^ElnaTreePointerTypeExpression); +var + result: ^ElnaTypePointer; +begin + result := malloc(#size(ElnaTypePointer)); + + result^.kind := ElnaTypeKind.pointer; + result^.size := 4; + result^.base := elna_name_type_expression(parser_node^.base); + + return result +end; + +proc elna_name_array_type_expression(parser_node: ^ElnaTreeArrayTypeExpression); +var + base: ^ElnaType; + result: ^ElnaTypeArray; + length: ^ElnaTreeIntegerLiteral; +begin + result := malloc(#size(ElnaTypeArray)); + base := elna_name_type_expression(parser_node^.base); + + (* Expected to be an integer literal for now. *) + length := parser_node^.length; + + result^.kind := ElnaTypeKind.pointer; + (* Array size in bytes. *) + result^.size := base^.size * length; + result^.base := base; + result^.length := length^.value; + + return result +end; + +proc elna_name_record_type_expression(parser_node: ^ElnaTreeRecordTypeExpression); +var + result: ^ElnaTypeRecord; + memory_start: Word; + member_count: Word; + member_array_start: Word; + member_array_current: ^ElnaTypeField; + field_definition_size: Word; + field_type: Word; +begin + result := malloc(#size(ElnaTypeRecord)); + + memory_start := parser_node^.members; + member_count := parser_node^.length; + + field_definition_size := #size(ElnaTypeField); + member_array_start := malloc(member_count * field_definition_size); + member_array_current := member_array_start; + + .elna_name_type_record_loop; + if member_count > 0 then + member_array_current^.name := memory_start^; + memory_start := memory_start + 4; + + member_array_current^.length := memory_start^; + memory_start := memory_start + 4; + + field_type := elna_name_type_expression(memory_start^); + member_array_current^.field_type := field_type; + + member_array_current := member_array_current + field_definition_size; + memory_start := memory_start + 4; + + memory_start := memory_start^; + member_count := member_count - 1; + goto elna_name_type_record_loop + end; + + result^.kind := ElnaTypeKind._record; + result^.size := parser_node^.length * 4; + result^.members := member_array_start; + result^.length := parser_node^.length; + + return result +end; + +proc elna_parser_named_type_expression(); +var + result: ^ElnaTreeNamedTypeExpression; +begin + result := malloc(#size(ElnaTreeNamedTypeExpression)); + + result^.kind := ElnaTreeKind.named_type_expression; + result^.name := _elna_lexer_global_get_start(); + result^.length := _elna_lexer_global_get_end() - result^.name; + _elna_lexer_skip_token(); + + return result +end; + +proc elna_parser_pointer_type_expression(); +var + result: ^ElnaTreePointerTypeExpression; +begin + _elna_lexer_skip_token(); + + result := malloc(#size(ElnaTreePointerTypeExpression)); + result^.kind := ElnaTreeKind.pointer_type_expression; + result^.base := elna_parser_type_expression(); + + return result +end; + +proc elna_parser_array_type_expression(); +var + result: ^ElnaTreeArrayTypeExpression; + token_kind: Word; +begin + _elna_lexer_skip_token(); + + result := malloc(#size(ElnaTreeArrayTypeExpression)); + result^.kind := ElnaTreeKind.array_type_expression; + result^.base := elna_parser_binary_expression(); + + (* Read and skip square bracket. *) + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + result^.base := elna_parser_type_expression(); + + return result +end; + +proc elna_parser_type_expression(); +var + token_kind: Word; + result: Word; +begin + result := nil; + _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() + elsif token_kind = ElnaLexerKind.hat then + result := elna_parser_pointer_type_expression() + elsif token_kind = ElnaLexerKind.left_square then + result := elna_parser_array_type_expression() + end; + return result +end; + +proc elna_name_type_expression(parser_node: ^ElnaTreeNode); +var + named_type_expression: ^ElnaTreeNamedTypeExpression; + type_symbol: ^ElnaSymbolTypeInfo; + result: Word; +begin + if parser_node^.kind = ElnaTreeKind.named_type_expression then + named_type_expression := parser_node; + + type_symbol := _symbol_table_lookup(@symbol_table_global, named_type_expression^.name, named_type_expression^.length); + result := type_symbol^._type + elsif parser_node^.kind = ElnaTreeKind.enumeration_type_expression then + result := elna_name_enumeration_type_expression(parser_node) + elsif parser_node^.kind = ElnaTreeKind.record_type_expression then + result := elna_name_record_type_expression(parser_node) + elsif parser_node^.kind = ElnaTreeKind.pointer_type_expression then + result := elna_name_pointer_type_expression(parser_node) + elsif parser_node^.kind = ElnaTreeKind.array_type_expression then + result := elna_name_array_type_expression(parser_node) + end; + + return result +end; + +proc _type_info_create(type_representation: Word); +var + result: ^ElnaSymbolTypeInfo; +begin + result := malloc(#size(ElnaSymbolTypeInfo)); + result^.kind := ElnaSymbolInfoKind.type_info; + result^._type := type_representation; + + return result +end; + +(** + * Parameters: + * temporary_index - Local variable index. + * temporary_type - Local variable type. + *) +proc _temporary_info_create(temporary_index: Word, temporary_type: Word); +var + result: ^ElnaSymbolTemporaryInfo; +begin + result := malloc(#size(ElnaSymbolTemporaryInfo)); + result^.kind := ElnaSymbolInfoKind.temporary_info; + + (* Calculate the stack offset: 4 * variable_counter. *) + result^.offset := temporary_index * 4; + result^.variable_type := temporary_type; + + return result +end; + +(** + * Parameters: + * symbol_table - Local symbol table. + *) +proc _procedure_info_create(symbol_table: Word); +var + result: ^ElnaSymbolProcedureInfo; +begin + result := malloc(#size(ElnaSymbolProcedureInfo)); + result^.kind := ElnaSymbolInfoKind.procedure_info; + result^.symbol_table := symbol_table; + + return result +end; + +(** + * Parameters: + * variable_index - Variable index. + *) +proc elna_name_procedure_temporary(parser_node: ^ElnaTreeVariableDeclaration, variable_index: Word, symbol_table: Word); +var + info: Word; + variable_type1: Word; +begin + variable_type1 := elna_name_type_expression(parser_node^._type); + + info := _temporary_info_create(variable_index, variable_type1); + _symbol_table_enter(symbol_table, parser_node^.name, parser_node^.length, info) +end; + +proc elna_name_procedure_temporaries(parser_node: ^ElnaTreeVariableDeclaration, symbol_table: Word); +var + temporary_counter: Word; +begin + temporary_counter := 0; + + .elna_name_procedure_temporaries_loop; + if parser_node <> nil then + elna_name_procedure_temporary(parser_node, temporary_counter, symbol_table); + + temporary_counter := temporary_counter + 1; + parser_node := parser_node^.next; + goto elna_name_procedure_temporaries_loop + end +end; + +proc elna_parser_procedure_declaration(); +var + next_declaration: ^ElnaTreeDeclaration; + current_declaration: ^ElnaTreeDeclaration; + token_kind: Word; + result: ^ElnaTreeProcedureDeclaration; + parameter_head: ^ElnaTreeDeclaration; +begin + result := malloc(#size(ElnaTreeProcedureDeclaration)); + + result^.kind := ElnaTreeKind.procedure_declaration; + result^.next := nil; + + (* Skip "proc ". *) + _elna_lexer_skip_token(); + + _elna_lexer_read_token(@token_kind); + + result^.name := _elna_lexer_global_get_start(); + result^.length := _elna_lexer_global_get_end() - result^.name; + (* Skip procedure name. *) + _elna_lexer_skip_token(); + + (* Skip open paren. *) + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + parameter_head := nil; + + .elna_parser_procedure_declaration_parameter; + _elna_lexer_read_token(@token_kind); + + if token_kind <> ElnaLexerKind.right_paren then + next_declaration := elna_parser_variable_declaration(); + if parameter_head = nil then + parameter_head := next_declaration + else + current_declaration^.next := next_declaration + end; + current_declaration := next_declaration; + + _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(); + result^.parameters := parameter_head; + + (* Skip semicolon and newline. *) + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + parameter_head := elna_parser_var_part(); + result^.temporaries := 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; + result^.body := parameter_head; + + (* Skip the "end" keyword. *) + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + return result +end; + +proc elna_tac_parameters(ast_list: ^ElnaTreeDeclaration, parameter_count: ^Word); +var + ast_parameter: ^ElnaTreeDeclaration; + parameter_index: Word; + current_parameter: Word; + parameter_list: Word; +begin + ast_parameter := ast_list; + parameter_count^ := 0; + + .elna_tac_parameters_count; + if ast_parameter <> nil then + ast_parameter := ast_parameter^.next; + parameter_count^ := parameter_count^ + 1; + + goto elna_tac_parameters_count + end; + (* The parameters are saved as an array of name pointer + name length. *) + parameter_list := malloc(parameter_count^ * 8); + current_parameter := parameter_list; + + ast_parameter := ast_list; + parameter_index := 0; + + .elna_tac_parameters_loop; + if parameter_index < parameter_count^ then + current_parameter^ := ast_parameter^.name; + current_parameter := current_parameter + 4; + current_parameter^ := ast_parameter^.length; + current_parameter := current_parameter + 4; + + parameter_index := parameter_index + 1; + ast_parameter := ast_parameter^.next; + goto elna_tac_parameters_loop + end; + + return parameter_list +end; + +proc elna_rtl_global_declaration(tac_declaration: ^ElnaInstructionDeclaration); +var + result: ElnaInstructionDeclaration; +begin + result := malloc(#size(ElnaInstructionDeclaration)); + + result^.next := 0; + result^.name := tac_declaration^.name; + result^.length := tac_declaration^.length; + result^.body := tac_declaration^.body; + + return result +end; + +proc elna_rtl_parameters(parameters: Word, count: Word); +var + result: Word; + current_instruction: Word; + last_instruction: Word; + parameter_index: Word; + parameter_name: Word; + name_length: Word; +begin + result := nil; + parameter_index := 0; + + .elna_rtl_parameters_loop; + if parameter_index < count then + parameter_name := parameters^; + parameters := parameters + 4; + name_length := parameters^; + parameters := parameters + 4; + + current_instruction := elna_rtl_instruction_create(ElnaRtlOperator.move); + elna_rtl_instruction_set_operand(current_instruction, 1, ElnaRtlOperand.pseudo, parameter_name, name_length); + elna_rtl_instruction_set_operand(current_instruction, 2, ElnaRtlOperand.register, 11 + parameter_index, 0); + + if result = nil then + result := current_instruction + else + elna_instruction_list_concatenate(last_instruction, current_instruction) + end; + last_instruction := current_instruction; + + parameter_index := parameter_index + 1; + goto elna_rtl_parameters_loop + end; + + return result +end; + +proc elna_rtl_procedure_declaration(tac_declaration: ^ElnaInstructionDeclaration); +var + result: ^ElnaInstructionDeclaration; + body: ^ElnaInstructionList; + parameters: ^ElnaInstructionList; +begin + result := malloc(#size(ElnaInstructionDeclaration)); + + result^.next := nil; + result^.name := tac_declaration^.name; + result^.length := tac_declaration^.length; + result^.stack := tac_declaration^.stack; + + parameters = elna_rtl_parameters(tac_declaration^.parameters, tac_declaration^.count); + body := elna_rtl_instructions(tac_declaration^.body); + result^.body := elna_instruction_list_concatenate(parameters, body); + + return result +end; + +proc elna_tac_procedure_declaration(parser_node: ElnaTreeProcedureDeclaration); +var + symbol_info: ^ElnaSymbolProcedureInfo; + result: ^ElnaInstructionDeclaration; + parameter_count: Word; +begin + result := malloc(#size(ElnaInstructionDeclaration)); + + result^.next := nil; + result^.stack := 1; + + result^.name := parser_node^.name; + result^.length := parser_node^.length; + + symbol_info := _symbol_table_lookup(@symbol_table_global, parser_node^.name, parser_node^.length); + + result^.parameters := elna_tac_parameters(parser_node^.parameters, @parameter_count); + result^.count := parameter_count; + result^.body := elna_tac_statements(parser_node^.body, symbol_info^.symbol_table); + + return result +end; + +proc elna_parser_procedures(); +var + parser_node: ^ElnaTreeDeclaration; + result: ^ElnaTreeDeclaration; + current_declaration: ^ElnaTreeDeclaration; + token_kind: Word; +begin + result := nil; + + .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 + current_declaration^.next := 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_rtl_globals(tac_procedure: ^ElnaInstructionList); +var + current_copy: ^ElnaInstructionList; + next_copy: Word; + first_copy: ^ElnaInstructionList; +begin + if tac_procedure <> 0 then + first_copy := elna_rtl_global_declaration(tac_procedure); + tac_procedure := tac_procedure^.next + else + first_copy := nil + end; + current_copy := first_copy; + + .elna_rtl_globals_start; + + if tac_procedure <> 0 then + next_copy := elna_rtl_global_declaration(tac_procedure); + + tac_procedure := tac_procedure^.next; + current_copy^.next := next_copy; + current_copy := next_copy; + goto elna_rtl_globals_start + end; + + return first_copy +end; + +proc elna_rtl_procedures(tac_procedure: ^ElnaInstructionList); +var + current_copy: ^ElnaInstructionList; + next_copy: Word; + first_copy: ^ElnaInstructionList; +begin + if tac_procedure <> nil then + first_copy := elna_rtl_procedure_declaration(tac_procedure); + tac_procedure := tac_procedure^.next + else + first_copy := nil; + end; + current_copy := first_copy; + + .elna_rtl_procedures_start; + + if tac_procedure <> nil then + next_copy := elna_rtl_procedure_declaration(tac_procedure); + + tac_procedure := tac_procedure^.next; + current_copy^.next := next_copy; + current_copy := next_copy; + goto elna_rtl_procedures_start + end; + + return first_copy +end; + +proc elna_tac_procedures(parser_node: ^ElnaTreeDeclaration); +var + result: Word; + current_procedure: ^ElnaInstructionList; + first_procedure: Word; +begin + first_procedure := nil; + + .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 = nil then + first_procedure := result + else + current_procedure^.next := result + end; + current_procedure := result; + + parser_node := parser_node^.next; + 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; + result: ^ElnaTreeTypeDeclaration; +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(); + + result := malloc(#size(ElnaTreeTypeDeclaration)); + + result^.kind := ElnaTreeKind.type_declaration; + result^.next := nil; + result^.name := type_name; + result^.length := name_length; + result^._type := elna_parser_type_expression(); + + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + return result +end; + +proc elna_name_type_declaration(parser_node: ^ElnaTreeTypeDeclaration); +var + type_name: Word; + name_length: Word; + type_info: Word; +begin + type_name := parser_node^.name; + name_length := parser_node^.length; + + parser_node := parser_node^._type; + type_info := elna_name_type_expression(parser_node); + type_info := _type_info_create(type_info); + + _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: ^ElnaTreeDeclaration; + result: ^ElnaTreeDeclaration; + current_declaration: ^ElnaTreeDeclaration; +begin + result := nil; + _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 = nil then + result := parser_node + else + current_declaration^.next := 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_type1: Word; + result: ^ElnaTreeVariableDeclaration; +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_type1 := elna_parser_type_expression(); + result := malloc(#size(ElnaTreeVariableDeclaration)); + + result^.kind := ElnaTreeKind.variable_declaration; + result^.next := nil; + result^.name := name; + result^.length := name_length; + result^._type := variable_type1; + + return result +end; + +proc elna_tac_variable_declaration(parser_tree: ^ElnaTreeVariableDeclaration); +var + name: Word; + name_length: Word; + variable_type: ^ElnaTreeNamedTypeExpression; + result: ^ElnaInstructionDeclaration; +begin + result := malloc(#size(ElnaInstructionDeclaration)); + + result^.next := nil; + + name := parser_tree^.name; + name_length := parser_tree^.length; + variable_type := parser_tree^._type; + + result^.name := name; + result^.length := name_length; + + name := variable_type^.name; + name_length := variable_type^.length; + + if string_compare("Array", 5, name, name_length) then + (* Else we assume this is a zeroed 4096 bytes big array. *) + result^.body := 4096 + else + result^.body := 4 + end; + return result +end; + +proc elna_parser_var_part(); +var + result: Word; + token_kind: Word; + variable_node: Word; + current_declaration: ^ElnaTreeDeclaration; +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 + current_declaration^.next := 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: ^ElnaTreeDeclaration); +var + node: Word; + current_variable: ^ElnaInstructionList; + 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 + current_variable^.next := node + end; + current_variable := node; + + parser_node := parser_node^.next; + 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(error_list: ^ElnaErrorList); +var + parser_node: Word; + result: ^ElnaTreeModuleDeclaration; + token_kind: Word; + parser_error: ^ElnaError; +begin + result := malloc(#size(ElnaTreeModuleDeclaration)); + result^.kind := ElnaTreeKind.module_declaration; + + (* Skip "program;". *) + _skip_empty_lines(); + _elna_lexer_read_token(@token_kind); + + if token_kind <> ElnaLexerKind._program then + parser_error := malloc(#size(ElnaError)); + parser_error^.next := nil; + + error_list^.first := parser_error; + error_list^.last := parser_error + else + _elna_lexer_skip_token(); + _elna_lexer_read_token(@token_kind); + _elna_lexer_skip_token(); + + result^.types := elna_parser_type_part(); + result^.globals := elna_parser_var_part(); + result^.procedures := elna_parser_procedures() + end; + return result +end; + +(** + * Process the source code and print the generated code. + *) +proc elna_tac_module_declaration(parser_node: ^ElnaTreeModuleDeclaration); +var + data_part: Word; + code_part: Word; +begin + data_part := elna_tac_var_part(parser_node^.globals); + code_part := elna_tac_procedures(parser_node^.procedures); + + return elna_instruction_module_create(data_part, code_part) +end; + +proc elna_name_procedure_declaration(parser_node: ^ElnaTreeProcedureDeclaration); +var + new_symbol_table: Word; + symbol_info: Word; +begin + new_symbol_table := _symbol_table_create(); + symbol_info := _procedure_info_create(new_symbol_table); + + elna_name_procedure_temporaries(parser_node^.parameters, new_symbol_table); + elna_name_procedure_temporaries(parser_node^.temporaries, new_symbol_table); + + _symbol_table_enter(@symbol_table_global, parser_node^.name, parser_node^.length, symbol_info) +end; + +proc elna_type_conditional_statements(parser_node: ^ElnaTreeConditionalStatements, symbol_table: Word); +begin + .elna_type_conditional_statements_loop; + elna_type_binary_expression(parser_node^.condition, symbol_table); + elna_type_statements(parser_node^.statements, symbol_table); + + parser_node := parser_node^.next; + if parser_node <> nil then + goto elna_type_conditional_statements_loop + end +end; + +proc elna_type_if_statement(parser_node: ^ElnaTreeIfStatement, symbol_table: Word); +var + block: ^ElnaTreeConditionalStatements; +begin + block := parser_node^.conditionals; + + .elna_type_if_statement_conditionals; + elna_type_conditional_statements(block, symbol_table); + + block := block^.next; + if block <> nil then + goto elna_type_if_statement_conditionals + end; + block := parser_node^._else; + if block <> nil then + elna_type_statements(block, symbol_table) + end +end; + +proc elna_type_return_statement(parser_node: ^ElnaTreeReturnStatement, symbol_table: Word); +begin + elna_type_binary_expression(parser_node^.returned, symbol_table) +end; + +proc elna_type_call(parser_node: Word, symbol_table: Word); +var + current_argument: Word; + argument_tree: Word; +begin + current_argument := 1; + + .elna_type_call_argument; + argument_tree := _call_get_argument(parser_node, current_argument); + + if argument_tree <> nil then + elna_type_binary_expression(argument_tree, symbol_table); + current_argument := current_argument + 1; + + goto elna_type_call_argument + end +end; + +proc elna_type_assign_statement(parser_node: ^ElnaTreeAssignStatement, symbol_table: Word); +begin + elna_type_designator(parser_node^.assignee, symbol_table); + elna_type_binary_expression(parser_node^.assignment, symbol_table) +end; + +proc elna_type_statement(parser_node: ^ElnaTreeNode, symbol_table: Word); +begin + (* Skipping goto and label declarations. *) + if parser_node^.kind = ElnaTreeKind.if_statement then + elna_type_if_statement(parser_node, symbol_table) + elsif parser_node^.kind = ElnaTreeKind.return_statement then + elna_type_return_statement(parser_node, symbol_table) + elsif parser_node^.kind = ElnaTreeKind.call then + elna_type_call(parser_node, symbol_table) + elsif parser_node^.kind = ElnaTreeKind.assign_statement then + elna_type_assign_statement(parser_node, symbol_table) + end +end; + +proc elna_type_statements(parser_node: ^ElnaTreeStatement, symbol_table: Word); +begin + .elna_type_statements_loop; + if parser_node <> nil then + elna_type_statement(parser_node, symbol_table); + + parser_node := parser_node^.next; + goto elna_type_statements_loop + end +end; + +proc elna_type_character_literal(parser_node: ^ElnaTreeCharacterLiteral); +var + symbol_info: ^ElnaSymbolTypeInfo; +begin + symbol_info := _symbol_table_lookup(@symbol_table_global, "Word", 4); + parser_node^.type_decoration := symbol_info^._type +end; + +proc elna_type_integer_literal(parser_node: ^ElnaTreeIntegerLiteral); +var + symbol_info: ^ElnaSymbolTypeInfo; +begin + symbol_info := _symbol_table_lookup(@symbol_table_global, "Word", 4); + parser_node^.type_decoration := symbol_info^._type +end; + +proc elna_type_string_literal(parser_node: ^ElnaTreeStringLiteral); +var + symbol_info: ^ElnaSymbolTypeInfo; +begin + symbol_info := _symbol_table_lookup(@symbol_table_global, "Word", 4); + parser_node^.type_decoration := symbol_info^._type +end; + +proc elna_type_boolean_literal(parser_node: ^ElnaTreeBooleanLiteral); +var + symbol_info: ^ElnaSymbolTypeInfo; +begin + symbol_info := _symbol_table_lookup(@symbol_table_global, "Bool", 4); + parser_node^.type_decoration := symbol_info^._type +end; + +proc elna_type_nil_literal(parser_node: ^ElnaTreeNilLiteral); +var + symbol_info: ^ElnaSymbolTypeInfo; +begin + symbol_info := _symbol_table_lookup(@symbol_table_global, "Pointer", 7); + parser_node^.type_decoration := symbol_info^._type +end; + +proc elna_type_variable_expression(parser_node: ^ElnaTreeVariableExpression, symbol_table: Word); +var + variable_info: ^ElnaSymbolInfo; + temporary_info: ^ElnaSymbolTemporaryInfo; +begin + variable_info := _symbol_table_lookup(symbol_table, parser_node^.name, parser_node^.length); + + if variable_info = nil then + variable_info := _symbol_table_lookup(@symbol_table_global, parser_node^.name, parser_node^.length) + end; + if variable_info^.kind = ElnaSymbolInfoKind.temporary_info then + temporary_info := variable_info; + parser_node^.type_decoration := temporary_info^.variable_type + end +end; + +proc elna_type_simple_expression(parser_node: ^ElnaTreeNode, symbol_table: Word); +begin + if parser_node^.kind = ElnaTreeKind.integer_literal then + elna_type_integer_literal(parser_node) + elsif parser_node^.kind = ElnaTreeKind.character_literal then + elna_type_character_literal(parser_node) + elsif parser_node^.kind = ElnaTreeKind.string_literal then + elna_type_string_literal(parser_node) + elsif parser_node^.kind = ElnaTreeKind.boolean_literal then + elna_type_boolean_literal(parser_node) + elsif parser_node^.kind = ElnaTreeKind.null then + elna_type_nil_literal(parser_node) + elsif parser_node^.kind = ElnaTreeKind.variable_expression then + elna_type_variable_expression(parser_node, symbol_table) + end +end; + +proc elna_type_dereference_expression(parser_node: ^ElnaTreeDereferenceExpression, symbol_table: Word); +var + base_type: ^ElnaType; + pointer_type: ^ElnaTypePointer; + dereferenced_expression: ^ElnaTreeExpression; +begin + elna_type_designator(parser_node^.pointer, symbol_table); + + dereferenced_expression := parser_node^.pointer; + base_type := dereferenced_expression^.type_decoration; + + (* If check for compatibility, should be removed later. *) + if base_type^.kind = ElnaTypeKind.pointer then + pointer_type := base_type; + base_type := pointer_type^.base; + end; + parser_node^.type_decoration := base_type +end; + +proc elna_type_field_access_expression(parser_node: ^ElnaTreeFieldAccessExpression, symbol_table: Word); +var + variable_expression: ^ElnaTreeVariableExpression; + base_type: Word; + type_kind: ^ElnaSymbolTypeInfo; + symbol_info: ^ElnaSymbolInfo; + aggregate_type: ^ElnaTypeRecord; + field_count: Word; + current_field: ^ElnaTypeField; +begin + base_type := nil; + variable_expression := parser_node^.aggregate; + + (* Check whether the field access is an enumeration value. *) + if variable_expression^.kind = ElnaTreeKind.variable_expression then + symbol_info := _symbol_table_lookup(@symbol_table_global, variable_expression^.name, variable_expression^.length); + if symbol_info <> nil then + type_kind := symbol_info; + + if symbol_info^.kind = ElnaSymbolInfoKind.type_info then + base_type := type_kind^._type + end + end + end; + (* If the base_type is still nil this is record field access. *) + if base_type = nil then + elna_type_designator(parser_node^.aggregate, symbol_table); + aggregate_type := variable_expression^.type_decoration; + + field_count := aggregate_type^.length; + current_field := aggregate_type^.members; + + .elna_type_field_access_expression_field; + + if string_compare(parser_node^.field, parser_node^.length, current_field^.name, current_field^.length) = 0 then + field_count := field_count - 1; + current_field := current_field + #size(ElnaTypeField); + goto elna_type_field_access_expression_field + end; + base_type := current_field^.field_type + end; + + parser_node^.type_decoration := base_type +end; + +proc elna_type_designator(parser_node: ^ElnaTreeNode, symbol_table: Word); +begin + if parser_node^.kind = ElnaTreeKind.dereference_expression then + elna_type_dereference_expression(parser_node, symbol_table) + elsif parser_node^.kind = ElnaTreeKind.field_access_expression then + elna_type_field_access_expression(parser_node, symbol_table) + elsif parser_node^.kind = ElnaTreeKind.call then + elna_type_call(parser_node, symbol_table) + else + elna_type_simple_expression(parser_node, symbol_table) + end +end; + +proc elna_type_unary_expression(parser_node: ^ElnaTreeUnaryExpression, symbol_table: Word); +var + unary_operand: ^ElnaTreeExpression; +begin + if parser_node^.kind = ElnaTreeKind.unary_expression then + unary_operand := parser_node^.operand; + elna_type_designator(unary_operand, symbol_table); + + parser_node^.type_decoration := unary_operand^.type_decoration + else + elna_type_designator(parser_node, symbol_table) + end +end; + +proc elna_type_binary_expression(parser_node: ^ElnaTreeBinaryExpression, symbol_table: Word); +var + binary_operand: ^ElnaTreeExpression; +begin + if parser_node^.kind = ElnaTreeKind.binary_expression then + elna_type_unary_expression(parser_node^.rhs, symbol_table); + + binary_operand := parser_node^.lhs; + elna_type_unary_expression(binary_operand, symbol_table); + + parser_node^.type_decoration := binary_operand^.type_decoration + else + elna_type_unary_expression(parser_node, symbol_table) + end +end; + +proc elna_type_procedure_declaration(parser_node: ^ElnaTreeProcedureDeclaration); +var + procedure_info: ^ElnaSymbolProcedureInfo; + symbol_table: Word; +begin + procedure_info := _symbol_table_lookup(@symbol_table_global, parser_node^.name, parser_node^.length); + symbol_table := procedure_info^.symbol_table; + + elna_type_statements(parser_node^.body, symbol_table) +end; + +proc elna_name_module_declaration(parser_node: ^ElnaTreeModuleDeclaration); +var + current_part: ^ElnaTreeDeclaration; +begin + current_part := parser_node^.types; + .elna_name_module_declaration_type; + if current_part <> nil then + elna_name_type_declaration(current_part); + current_part := current_part^.next; + + goto elna_name_module_declaration_type + end; + current_part := parser_node^.globals; + .elna_name_module_declaration_global; + if current_part <> nil then + elna_name_procedure_temporary(current_part, 0, @symbol_table_global); + current_part := current_part^.next; + + goto elna_name_module_declaration_global + end; + current_part := parser_node^.procedures; + .elna_name_module_declaration_procedure; + if current_part <> nil then + elna_name_procedure_declaration(current_part); + current_part := current_part^.next; + + goto elna_name_module_declaration_procedure + end +end; + +proc elna_type_module_declaration(parser_node: ^ElnaTreeModuleDeclaration); +var + current_part: ^ElnaTreeDeclaration; +begin + current_part := parser_node^.types; + .elna_type_module_declaration_type; + if current_part <> 0 then + elna_type_type_declaration(current_part); + current_part := current_part^.next; + + goto elna_type_module_declaration_type + end; + + current_part := parser_node^.procedures; + .elna_type_module_declaration_procedure; + if current_part <> 0 then + elna_type_procedure_declaration(current_part); + current_part := current_part^.next; + + goto elna_type_module_declaration_procedure + end +end; + +proc _compile(); +var + parser_node: Word; + tac: Word; + rtl: Word; + error_list: ^ElnaErrorList; + compiled: Word; +begin + error_list := malloc(#size(ElnaErrorList)); + error_list^.first := nil; + error_list^.last := nil; + + parser_node := elna_parser_module_declaration(error_list); + compiled := error_list^.first = nil; + + if compiled then + elna_name_module_declaration(parser_node); + elna_type_module_declaration(parser_node); + tac := elna_tac_module_declaration(parser_node); + rtl := elna_rtl_module_declaration(tac); + elna_alloc_module(rtl); + elna_riscv_module(rtl); + end; + + return compiled +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: ^ElnaSymbolTypeInfo; + current_type: ^ElnaType; +begin + (* Set the table length to 0. *) + symbol_table_global := 0; + + (* Enter built-in symbols. *) + current_type := malloc(#size(ElnaType)); + current_type^.kind := ElnaTypeKind.primitive; + current_type^.size := 4; + current_info := _type_info_create(current_type); + _symbol_table_enter(@symbol_table_global, "Word", 4, current_info); + + current_type := malloc(#size(ElnaType)); + current_type^.kind := ElnaTypeKind.primitive; + current_type^.size := 4; + current_info := _type_info_create(current_type); + _symbol_table_enter(@symbol_table_global, "Pointer", 7, current_info); + + current_type := malloc(#size(ElnaType)); + current_type^.kind := ElnaTypeKind.primitive; + current_type^.size := 1; + current_info := _type_info_create(current_type); + _symbol_table_enter(@symbol_table_global, "Bool", 4, current_info); + + current_type := malloc(#size(ElnaType)); + current_type^.kind := ElnaTypeKind.primitive; + current_type^.size := 4096; + 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.number_sign); + _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 23 character classes, so a transition row 8 * 23 = 184 bytes long. *) + row_position := current_state - 1; + row_position := row_position * 184; + + 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); + _elna_lexer_set_transition(current_state, ElnaLexerClass.number_sign, 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); + _elna_lexer_set_transition(ElnaLexerState.start, ElnaLexerClass.number_sign, ElnaLexerAction.accumulate, ElnaLexerState.number_sign); + + (* 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); + + (* Number sign state. *) + _elna_lexer_default_transition(ElnaLexerState.number_sign, ElnaLexerAction.key_id, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.number_sign, ElnaLexerClass.alpha, ElnaLexerAction.accumulate, ElnaLexerState.trait); + _elna_lexer_set_transition(ElnaLexerState.number_sign, ElnaLexerClass.hex, ElnaLexerAction.accumulate, ElnaLexerState.trait); + _elna_lexer_set_transition(ElnaLexerState.number_sign, ElnaLexerClass.x, ElnaLexerAction.accumulate, ElnaLexerState.trait); + + (* Trait state. *) + _elna_lexer_default_transition(ElnaLexerState.trait, ElnaLexerAction.key_id, ElnaLexerState.finish); + _elna_lexer_set_transition(ElnaLexerState.trait, ElnaLexerClass.digit, ElnaLexerAction.accumulate, ElnaLexerState.trait); + _elna_lexer_set_transition(ElnaLexerState.trait, ElnaLexerClass.alpha, ElnaLexerAction.accumulate, ElnaLexerState.trait); + _elna_lexer_set_transition(ElnaLexerState.trait, ElnaLexerClass.hex, ElnaLexerAction.accumulate, ElnaLexerState.trait); + _elna_lexer_set_transition(ElnaLexerState.trait, ElnaLexerClass.zero, ElnaLexerAction.accumulate, ElnaLexerState.trait); + _elna_lexer_set_transition(ElnaLexerState.trait, ElnaLexerClass.x, ElnaLexerAction.accumulate, ElnaLexerState.trait) +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 19 rows (transition states) + * and 23 columns (character classes), so 3496 = 8 * 19 * 23. + *) +proc _elna_lexer_global_state(); +var + result: Word; +begin + result := _elna_lexer_get_transition_table(); + return result + 3496 +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 _load_byte(position_start) = '#' then + result := ElnaLexerKind.trait + elsif 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", 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 + elsif string_compare(position_start, token_length, "true", 4) then + result := ElnaLexerKind.boolean + elsif string_compare(position_start, token_length, "false", 5) then + result := ElnaLexerKind.boolean + 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; + source_code := malloc(495616); + symbol_table_store := malloc(4194304); +end; + +(* + * Entry point. + *) +proc main(); +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(0, offset, 409600); + if last_read > 0 then + offset := offset + last_read; + goto start_read + end; + if _compile() then + exit(0) + else + exit(4) + end; +end; diff --git a/boot/stage18/linker.arg b/boot/stage18/linker.arg new file mode 100644 index 0000000..e69de29