diff --git a/Rakefile b/Rakefile index f66b9eb..c2f5be5 100644 --- a/Rakefile +++ b/Rakefile @@ -49,12 +49,18 @@ task :convert do x: ElnaLocation; y: ElnaLocation; begin + y.line := 1; + y.column := 3; x := y; + printf("# %i %i %i %i\\n\\0", x.line, x.column, y.line, y.column) end; + begin + f(); FUN + else + current_stage << line end - current_stage << line end end end diff --git a/boot/stage21/cl.elna b/boot/stage21/cl.elna index 4636589..061d860 100644 --- a/boot/stage21/cl.elna +++ b/boot/stage21/cl.elna @@ -210,6 +210,11 @@ type array: Word; index: ^ElnaTreeExpression end; + ElnaTreeEnumeration = record + name: Word; + length: Word; + next: Word + end; ElnaTreeEnumerationTypeExpression = record kind: ElnaTreeKind; members: Word; @@ -672,7 +677,7 @@ var * * Returns the length in a0. *) -proc _string_length(string: Word); +proc _string_length(string: Word) -> Word; var counter: Word; current_byte: Word; @@ -802,7 +807,7 @@ end; (** * Appends a new element to the end of the list. *) -proc elna_list_append(list: ^ElnaList, element: ^ElnaListNode); +proc elna_list_append(list: ^ElnaList, element: ^ElnaListNode) -> ^ElnaListNode; begin if element <> nil then if list^.first = nil then @@ -877,13 +882,13 @@ begin return result end; -proc elna_rtl_instruction_create(kind: Word); +proc elna_rtl_instruction_create(operator: ElnaRtlOperator) -> ^ElnaRtlInstruction; var result: ^ElnaRtlInstruction; begin result := malloc(#size(ElnaRtlInstruction)); - result^.operator := kind; + result^.operator := operator; result^.next := nil; return result @@ -1097,8 +1102,6 @@ begin elna_rtl_instruction_set_operand(instruction, 2, ElnaRtlKind.pseudo_mem, addressable^.value, addressable^.length, 0) else - (* Debug - printf("# %.*s, %i\n\0", addressable^.length, addressable^.value, pseudo_symbol^.rtl_type^.kind); *) elna_rtl_instruction_set_operand(instruction, 2, ElnaRtlKind.pseudo, addressable^.value, addressable^.length, 0) end; @@ -1255,6 +1258,7 @@ var source_operand: ElnaRtlOperand; target_operand: ElnaRtlOperand; pseudo_symbol: ^ElnaRtlInfo; + byte_array: ^ElnaRtlTypeByteArray; begin elna_rtl_operand_value(instructions, @tac_instruction^.operands[1], variable_map, @source_operand); pseudo_symbol := elna_symbol_table_lookup(variable_map, @@ -1262,8 +1266,8 @@ begin if pseudo_symbol = nil then elna_rtl_generate_pseudo(@target_operand, variable_map); - instruction := elna_rtl_instruction_create(ElnaRtlOperator.la); + instruction := elna_rtl_instruction_create(ElnaRtlOperator.la); elna_rtl_instruction_set_operand(instruction, 1, target_operand.kind, target_operand.value, target_operand.length, 0); elna_rtl_instruction_set_operand(instruction, 2, ElnaRtlKind.data, tac_instruction^.operands[2].value, tac_instruction^.operands[2].length, 0); @@ -1273,12 +1277,34 @@ begin elna_rtl_instruction_set_operand(instruction, 1, source_operand.kind, source_operand.value, source_operand.length, 0); elna_rtl_instruction_set_operand(instruction, 2, target_operand.kind, target_operand.value, target_operand.length, 0); elna_list_append(instructions, instruction) - else + elsif source_operand.kind = ElnaRtlKind.pseudo then instruction := elna_rtl_instruction_create(ElnaRtlOperator.mv); elna_rtl_instruction_set_operand(instruction, 1, ElnaRtlKind.pseudo, tac_instruction^.operands[2].value, tac_instruction^.operands[2].length, 0); elna_rtl_instruction_set_operand(instruction, 2, source_operand.kind, source_operand.value, source_operand.length, 0); elna_list_append(instructions, instruction); + else + byte_array := pseudo_symbol^.rtl_type; + + instruction := elna_rtl_instruction_create(ElnaRtlOperator.la); + elna_rtl_instruction_set_operand(instruction, 1, ElnaRtlKind.register, ElnaRtlRegister.a0, 0, 0); + elna_rtl_instruction_set_operand(instruction, 2, ElnaRtlKind.pseudo, + tac_instruction^.operands[2].value, tac_instruction^.operands[2].length, 0); + elna_list_append(instructions, instruction); + + instruction := elna_rtl_instruction_create(ElnaRtlOperator.la); + elna_rtl_instruction_set_operand(instruction, 1, ElnaRtlKind.register, ElnaRtlRegister.a1, 0, 0); + elna_rtl_instruction_set_operand(instruction, 2, source_operand.kind, source_operand.value, source_operand.length, 0); + elna_list_append(instructions, instruction); + + instruction := elna_rtl_instruction_create(ElnaRtlOperator.li); + elna_rtl_instruction_set_operand(instruction, 1, ElnaRtlKind.register, ElnaRtlRegister.a2, 0, 0); + elna_rtl_instruction_set_operand(instruction, 2, ElnaRtlKind.immediate, byte_array^.size, 0, 0); + elna_list_append(instructions, instruction); + + instruction := elna_rtl_instruction_create(ElnaRtlOperator.jal); + elna_rtl_instruction_set_operand(instruction, 1, ElnaRtlKind.data, "memcpy", 6, 0); + elna_list_append(instructions, instruction) end end; @@ -1370,7 +1396,7 @@ begin elna_list_append(instructions, result) end; -proc elna_riscv_instruction_name(instruction_kind: Word); +proc elna_riscv_instruction_name(instruction_kind: ElnaRtlOperator) -> Word; var argument_count: Word; begin @@ -1483,7 +1509,8 @@ begin end end; -proc elna_alloc_variable(operand_value: Word, operand_length: Word, variable_map: ^ElnaSymbolTable); +proc elna_alloc_variable(operand_value: Word, operand_length: Word, + variable_map: ^ElnaSymbolTable) -> ^ElnaRtlInfo; var pseudo_symbol: ^ElnaRtlInfo; pseudo_type: ^ElnaRtlTypeByteArray; @@ -1553,7 +1580,8 @@ begin end end; -proc elna_alloc_store(instructions: ^ElnaList, instruction: ^ElnaRtlInstruction, variable_map: ^ElnaSymbolTable); +proc elna_alloc_store(instructions: ^ElnaList, instruction: ^ElnaRtlInstruction, + variable_map: ^ElnaSymbolTable) -> ^ElnaRtlInstruction; var store_instruction: ^ElnaRtlInstruction; pseudo_symbol: ^ElnaRtlInfo; @@ -1580,7 +1608,8 @@ begin return instruction end; -proc elna_alloc_load(instructions: ^ElnaList, instruction: ^ElnaRtlInstruction, variable_map: ^ElnaSymbolTable); +proc elna_alloc_load(instructions: ^ElnaList, instruction: ^ElnaRtlInstruction, + variable_map: ^ElnaSymbolTable) -> ^ElnaRtlInstruction; var new_instruction: ^ElnaRtlInstruction; pseudo_symbol: ^ElnaRtlInfo; @@ -1606,7 +1635,8 @@ begin return elna_alloc_operation_target(instructions, instruction, variable_map) end; -proc elna_alloc_move(instructions: ^ElnaList, instruction: ^ElnaRtlInstruction, variable_map: ^ElnaSymbolTable); +proc elna_alloc_move(instructions: ^ElnaList, instruction: ^ElnaRtlInstruction, + variable_map: ^ElnaSymbolTable) -> ^ElnaRtlInstruction; var pseudo_symbol: ^ElnaRtlInfo; destination_pseudo: Word; @@ -1674,7 +1704,8 @@ begin return instruction end; -proc elna_alloc_binary(instructions: ^ElnaList, instruction: ^ElnaRtlInstruction, variable_map: ^ElnaSymbolTable) -> ^ElnaRtlInstruction; +proc elna_alloc_binary(instructions: ^ElnaList, instruction: ^ElnaRtlInstruction, + variable_map: ^ElnaSymbolTable) -> ^ElnaRtlInstruction; var new_instruction: ^ElnaRtlInstruction; pseudo_symbol: ^ElnaRtlInfo; @@ -1684,7 +1715,8 @@ begin return elna_alloc_operation_target(instructions, instruction, variable_map) end; -proc elna_alloc_unary(instructions: ^ElnaList, instruction: ^ElnaRtlInstruction, variable_map: ^ElnaSymbolTable) -> ^ElnaRtlInstruction; +proc elna_alloc_unary(instructions: ^ElnaList, instruction: ^ElnaRtlInstruction, + variable_map: ^ElnaSymbolTable) -> ^ElnaRtlInstruction; var new_instruction: ^ElnaRtlInstruction; pseudo_symbol: ^ElnaRtlInfo; @@ -1693,7 +1725,8 @@ begin return elna_alloc_operation_target(instructions, instruction, variable_map) end; -proc elna_alloc_instruction(instructions: ^ElnaList, instruction: ^ElnaRtlInstruction, variable_map: ^ElnaSymbolTable) -> ^ElnaRtlInstruction; +proc elna_alloc_instruction(instructions: ^ElnaList, instruction: ^ElnaRtlInstruction, + variable_map: ^ElnaSymbolTable) -> ^ElnaRtlInstruction; var pseudo_symbol: ^ElnaRtlInfo; new_instruction: ^ElnaRtlInstruction; @@ -1896,7 +1929,7 @@ begin end end; -proc elna_rtl_module_declaration(tac_module: ^ElnaInstructionModule); +proc elna_rtl_module_declaration(tac_module: ^ElnaInstructionModule) -> ^ElnaInstructionModule; var result: ^ElnaInstructionModule; begin @@ -2020,7 +2053,7 @@ begin return result end; -proc elna_parser_nil_literal(cursor: ^ElnaLexerCursor); +proc elna_parser_nil_literal(cursor: ^ElnaLexerCursor) -> ^ElnaTreeNilLiteral; var result: ^ElnaTreeNilLiteral; begin @@ -2166,7 +2199,7 @@ var parser_node: ^ElnaTreeExpression; token: ^ElnaLexerToken; begin - parser_node := 0; + parser_node := nil; token := elna_lexer_peek(cursor); if token^.kind = ElnaLexerKind.character then @@ -2187,7 +2220,8 @@ begin return parser_node end; -proc elna_parser_dereference_expression(cursor: ^ElnaLexerCursor, simple_expression: Word); +proc elna_parser_dereference_expression(cursor: ^ElnaLexerCursor, + simple_expression: ^ElnaTreeExpression) -> ^ElnaTreeDereferenceExpression; var result: ^ElnaTreeDereferenceExpression; begin @@ -2201,9 +2235,9 @@ begin return result end; -proc elna_parser_designator(cursor: ^ElnaLexerCursor); +proc elna_parser_designator(cursor: ^ElnaLexerCursor) -> ^ElnaTreeExpression; var - simple_expression: Word; + simple_expression: ^ElnaTreeExpression; token: ^ElnaLexerToken; begin simple_expression := elna_parser_simple_expression(cursor); @@ -2262,7 +2296,7 @@ begin end end; -proc elna_parser_unary_expression(cursor: ^ElnaLexerCursor); +proc elna_parser_unary_expression(cursor: ^ElnaLexerCursor) -> ^ElnaTreeExpression; var result: ^ElnaTreeUnaryExpression; operand: Word; @@ -2322,7 +2356,8 @@ begin end end; -proc elna_tac_unary_expression(instructions: ^ElnaList, parser_node: ^ElnaTreeUnaryExpression, symbol_table: ^ElnaSymbolTable, operand: ^ElnaTacOperand); +proc elna_tac_unary_expression(instructions: ^ElnaList, parser_node: ^ElnaTreeUnaryExpression, + symbol_table: ^ElnaSymbolTable, operand: ^ElnaTacOperand); var token_kind: Word; operator: Word; @@ -2379,10 +2414,10 @@ begin end end; -proc elna_parser_binary_expression(cursor: ^ElnaLexerCursor); +proc elna_parser_binary_expression(cursor: ^ElnaLexerCursor) -> ^ElnaTreeExpression; var - lhs_node: Word; - rhs_node: Word; + lhs_node: ^ElnaTreeExpression; + rhs_node: ^ElnaTreeExpression; result: ^ElnaTreeBinaryExpression; token: ^ElnaLexerToken; begin @@ -2433,7 +2468,7 @@ begin elna_lexer_read(cursor); rhs_node := elna_parser_unary_expression(cursor) end; - if rhs_node <> 0 then + if rhs_node <> nil then result := malloc(#size(ElnaTreeBinaryExpression)); result^.kind := ElnaTreeKind.binary_expression; @@ -2555,7 +2590,7 @@ begin end end; -proc elna_parser_call(cursor: ^ElnaLexerCursor, callee: Word); +proc elna_parser_call(cursor: ^ElnaLexerCursor, callee: ^ElnaTreeExpression) -> ^ElnaTreeCall; var result: ^ElnaTreeCall; argument_number: Word; @@ -2603,7 +2638,8 @@ begin return result end; -proc elna_tac_call(instructions: ^ElnaList, parsed_call: ^ElnaTreeCall, symbol_table: ^ElnaSymbolTable, operand: ^ElnaTacOperand); +proc elna_tac_call(instructions: ^ElnaList, parsed_call: ^ElnaTreeCall, symbol_table: ^ElnaSymbolTable, + operand: ^ElnaTacOperand); var parsed_expression: ^ElnaTreeVariableExpression; arguments_operand: ^ElnaTacOperand; @@ -2633,7 +2669,7 @@ begin elna_list_append(instructions, call_instruction) end; -proc elna_parser_goto_statement(cursor: ^ElnaLexerCursor); +proc elna_parser_goto_statement(cursor: ^ElnaLexerCursor) -> ^ElnaTreeGotoStatement; var result: ^ElnaTreeGotoStatement; token: ^ElnaLexerToken; @@ -2667,9 +2703,9 @@ begin elna_list_append(instructions, instruction) end; -proc elna_parser_label_declaration(cursor: ^ElnaLexerCursor); +proc elna_parser_label_declaration(cursor: ^ElnaLexerCursor) -> ^ElnaTreeLabelDeclaration; var - result: ^ElnaTreeGotoStatement; + result: ^ElnaTreeLabelDeclaration; token: ^ElnaLexerToken; begin elna_lexer_read(cursor); @@ -2730,7 +2766,8 @@ begin end end; -proc elna_parser_field_access_expression(cursor: ^ElnaLexerCursor, aggregate: Word); +proc elna_parser_field_access_expression(cursor: ^ElnaLexerCursor, + aggregate: ^ElnaTreeExpression) -> ^ElnaTreeFieldAccessExpression; var result: ^ElnaTreeFieldAccessExpression; token: ^ElnaLexerToken; @@ -2750,7 +2787,8 @@ begin return result end; -proc elna_parser_array_access_expression(cursor: ^ElnaLexerCursor, array: Word); +proc elna_parser_array_access_expression(cursor: ^ElnaLexerCursor, + array: ^ElnaTreeExpression) -> ^ElnaTreeArrayAccessExpression; var result: ^ElnaTreeArrayAccessExpression; begin @@ -2909,7 +2947,7 @@ begin elna_list_append(instructions, instruction) end; -proc elna_parser_assign_statement(cursor: ^ElnaLexerCursor, assignee: Word); +proc elna_parser_assign_statement(cursor: ^ElnaLexerCursor, assignee: ^ElnaTreeNode) -> ^ElnaTreeAssignStatement; var result: ^ElnaTreeAssignStatement; begin @@ -2960,9 +2998,9 @@ begin elna_list_append(instructions, instruction) end; -proc elna_parser_return_statement(cursor: ^ElnaLexerCursor); +proc elna_parser_return_statement(cursor: ^ElnaLexerCursor) -> ^ElnaTreeReturnStatement; var - returned: Word; + returned: ^ElnaTreeExpression; label_length: Word; result: ^ElnaTreeReturnStatement; begin @@ -3009,7 +3047,7 @@ begin fflush(nil) end; -proc elna_parser_conditional_statements(cursor: ^ElnaLexerCursor); +proc elna_parser_conditional_statements(cursor: ^ElnaLexerCursor) -> ^ElnaTreeConditionalStatements; var result: ^ElnaTreeConditionalStatements; begin @@ -3056,7 +3094,7 @@ begin elna_tac_label(instructions, condition_label, 0) end; -proc elna_parser_if_statement(cursor: ^ElnaLexerCursor); +proc elna_parser_if_statement(cursor: ^ElnaLexerCursor) -> ^ElnaTreeIfStatement; var result: ^ElnaTreeIfStatement; previous_conditional: ^ElnaTreeConditionalStatements; @@ -3091,9 +3129,10 @@ begin return result end; -proc elna_parser_statement(cursor: ^ElnaLexerCursor); +proc elna_parser_statement(cursor: ^ElnaLexerCursor) -> ^ElnaTreeStatement; var - result : ^ElnaTreeNode; + result: ^ElnaTreeStatement; + designator: ^ElnaTreeNode; token: ^ElnaLexerToken; begin result := nil; @@ -3108,10 +3147,12 @@ begin elsif token^.kind = ElnaLexerKind.dot then result := elna_parser_label_declaration(cursor) elsif token^.kind = ElnaLexerKind.identifier then - result := elna_parser_designator(cursor); + designator := elna_parser_designator(cursor); - if result^.kind <> ElnaTreeKind.call then - result := elna_parser_assign_statement(cursor, result) + if designator^.kind <> ElnaTreeKind.call then + result := elna_parser_assign_statement(cursor, designator) + else + result := designator end end; return result @@ -3224,7 +3265,7 @@ begin _write_c(register_number + '0') end; -proc elna_parser_record_type_expression(cursor: ^ElnaLexerCursor); +proc elna_parser_record_type_expression(cursor: ^ElnaLexerCursor) -> ^ElnaTreeRecordTypeExpression; var entry: ^ElnaTreeField; result: ^ElnaTreeRecordTypeExpression; @@ -3273,35 +3314,33 @@ begin return result end; -proc elna_parser_enumeration_type_expression(cursor: ^ElnaLexerCursor); +proc elna_parser_enumeration_type_expression(cursor: ^ElnaLexerCursor) -> ^ElnaTreeEnumerationTypeExpression; var - memory_start: Word; - member_count: Word; result: ^ElnaTreeEnumerationTypeExpression; - entry: Word; - previous_entry: Word; + entry: ^ElnaTreeEnumeration; + previous_entry: ^ElnaTreeEnumeration; token: ^ElnaLexerToken; begin elna_lexer_read(cursor); - memory_start := 0; - member_count := 0; + + result := malloc(#size(ElnaTreeEnumerationTypeExpression)); + result^.kind := ElnaTreeKind.enumeration_type_expression; + result^.members := nil; + result^.length := 0; .elna_parser_enumeration_type_expression_loop; token := elna_lexer_read(cursor); - entry := malloc(12); - member_count := member_count + 1; + entry := malloc(#size(ElnaTreeEnumeration)); + result^.length := result^.length + 1; - entry^ := token^.start; - entry := entry + 4; + entry^.name := token^.start; + entry^.length := token^.length; + entry^.next := nil; - entry^ := token^.length; - entry := entry + 4; - - entry^ := 0; - if memory_start = 0 then - memory_start := entry - 8 + if result^.members = nil then + result^.members := entry else - previous_entry^ := entry - 8 + previous_entry^.next := entry end; previous_entry := entry; @@ -3310,12 +3349,6 @@ begin if token^.kind = ElnaLexerKind.comma then goto elna_parser_enumeration_type_expression_loop end; - result := malloc(#size(ElnaTreeEnumerationTypeExpression)); - - result^.kind := ElnaTreeKind.enumeration_type_expression; - result^.members := memory_start; - result^.length := member_count; - return result end; @@ -3331,7 +3364,7 @@ end; * * Returns enumeration type description. *) -proc elna_name_enumeration_type_expression(parser_node: ^ElnaTreeEnumerationTypeExpression); +proc elna_name_enumeration_type_expression(parser_node: ^ElnaTreeEnumerationTypeExpression) -> ^ElnaTypeEnumeration; var result: ^ElnaTypeEnumeration; memory_start: Word; @@ -3373,7 +3406,7 @@ begin return result end; -proc elna_name_pointer_type_expression(parser_node: ^ElnaTreePointerTypeExpression); +proc elna_name_pointer_type_expression(parser_node: ^ElnaTreePointerTypeExpression) -> ^ElnaTypePointer; var result: ^ElnaTypePointer; begin @@ -3387,7 +3420,7 @@ begin return result end; -proc elna_name_array_type_expression(parser_node: ^ElnaTreeArrayTypeExpression); +proc elna_name_array_type_expression(parser_node: ^ElnaTreeArrayTypeExpression) -> ^ElnaTypeArray; var base: ^ElnaType; result: ^ElnaTypeArray; @@ -3409,34 +3442,30 @@ begin return result end; -proc elna_name_record_type_expression(parser_node: ^ElnaTreeRecordTypeExpression); +proc elna_name_record_type_expression(parser_node: ^ElnaTreeRecordTypeExpression) -> ^ElnaTypeRecord; var result: ^ElnaTypeRecord; - memory_start: Word; - member_count: Word; - member_array_start: Word; + tree_field: ^ElnaTreeField; + member_array_start: ^ElnaTypeField; member_array_current: ^ElnaTypeField; field_type: ^ElnaType; begin result := malloc(#size(ElnaTypeRecord)); + result^.kind := ElnaTypeKind._record; result^.size := 0; result^.alignment := 0; + result^.length := 0; + result^.members := malloc(parser_node^.length * #size(ElnaTypeField)); - memory_start := parser_node^.members; - member_count := parser_node^.length; - - member_array_start := malloc(member_count * #size(ElnaTypeField)); - member_array_current := member_array_start; + tree_field := parser_node^.members; + member_array_current := result^.members; .elna_name_type_record_loop; - if member_count > 0 then - member_array_current^.name := memory_start^; - memory_start := memory_start + 4; + if result^.length < parser_node^.length then + member_array_current^.name := tree_field^.name; + member_array_current^.length := tree_field^.length; - member_array_current^.length := memory_start^; - memory_start := memory_start + 4; - - field_type := elna_name_type_expression(memory_start^); + field_type := elna_name_type_expression(tree_field^.type_expression); result^.size := result^.size + field_type^.size; if field_type^.alignment > result^.alignment then result^.alignment := field_type^.alignment @@ -3444,21 +3473,16 @@ begin member_array_current^.field_type := field_type; member_array_current := member_array_current + 1; - memory_start := memory_start + 4; - memory_start := memory_start^; - member_count := member_count - 1; + tree_field := tree_field^.next; + result^.length := result^.length + 1; goto elna_name_type_record_loop end; - result^.kind := ElnaTypeKind._record; - result^.members := member_array_start; - result^.length := parser_node^.length; - return result end; -proc elna_parser_named_type_expression(cursor: ^ElnaLexerCursor); +proc elna_parser_named_type_expression(cursor: ^ElnaLexerCursor) -> ^ElnaTreeNamedTypeExpression; var result: ^ElnaTreeNamedTypeExpression; token: ^ElnaLexerToken; @@ -3473,7 +3497,7 @@ begin return result end; -proc elna_parser_pointer_type_expression(cursor: ^ElnaLexerCursor); +proc elna_parser_pointer_type_expression(cursor: ^ElnaLexerCursor) -> ^ElnaTreePointerTypeExpression; var result: ^ElnaTreePointerTypeExpression; begin @@ -3486,7 +3510,7 @@ begin return result end; -proc elna_parser_array_type_expression(cursor: ^ElnaLexerCursor); +proc elna_parser_array_type_expression(cursor: ^ElnaLexerCursor) -> ^ElnaTreeArrayTypeExpression; var result: ^ElnaTreeArrayTypeExpression; begin @@ -3504,9 +3528,9 @@ begin return result end; -proc elna_parser_type_expression(cursor: ^ElnaLexerCursor); +proc elna_parser_type_expression(cursor: ^ElnaLexerCursor) -> ^ElnaTreeNode; var - result: Word; + result: ^ElnaTreeNode; token: ^ElnaLexerToken; begin result := nil; @@ -3526,11 +3550,11 @@ begin return result end; -proc elna_name_type_expression(parser_node: ^ElnaTreeNode); +proc elna_name_type_expression(parser_node: ^ElnaTreeNode) -> ^ElnaType; var named_type_expression: ^ElnaTreeNamedTypeExpression; type_symbol: ^ElnaSymbolTypeInfo; - result: Word; + result: ^ElnaType; begin if parser_node^.kind = ElnaTreeKind.named_type_expression then named_type_expression := parser_node; @@ -3551,7 +3575,7 @@ begin return result end; -proc type_info_create(type_representation: Word); +proc type_info_create(type_representation: Word) -> ^ElnaSymbolTypeInfo; var result: ^ElnaSymbolTypeInfo; begin @@ -3567,7 +3591,7 @@ end; * attr - Local variable attributes. * temporary_type - Local variable type. *) -proc temporary_info_create(attr: Word, temporary_type: Word); +proc temporary_info_create(attr: Word, temporary_type: ^ElnaType) -> ^ElnaSymbolTemporaryInfo; var result: ^ElnaSymbolTemporaryInfo; begin @@ -3585,7 +3609,7 @@ end; * Parameters: * symbol_table - Local symbol table. *) -proc procedure_info_create(symbol_table: ^ElnaSymbolTable); +proc procedure_info_create(symbol_table: ^ElnaSymbolTable) -> ^ElnaSymbolProcedureInfo; var result: ^ElnaSymbolProcedureInfo; begin @@ -3699,7 +3723,7 @@ begin return result end; -proc elna_tac_parameters(ast_list: ^ElnaTreeDeclaration, parameter_count: ^Word); +proc elna_tac_parameters(ast_list: ^ElnaTreeDeclaration, parameter_count: ^Word) -> ^Word; var ast_parameter: ^ElnaTreeDeclaration; parameter_index: Word; @@ -3738,7 +3762,7 @@ begin return parameter_list end; -proc elna_rtl_global_declaration(tac_declaration: ^ElnaTacStaticVariable); +proc elna_rtl_global_declaration(tac_declaration: ^ElnaTacStaticVariable) -> ^ElnaRtlStaticVariable; var result: ^ElnaRtlStaticVariable; begin @@ -3752,7 +3776,7 @@ begin return result end; -proc elna_rtl_parameters(instructions: ^ElnaList, parameters: Word, count: Word); +proc elna_rtl_parameters(instructions: ^ElnaList, parameters: Word, count: Word) -> ^ElnaRtlInstruction; var result: ^ElnaRtlInstruction; instruction: ^ElnaRtlInstruction; @@ -3820,7 +3844,7 @@ begin return pseudo_symbol end; -proc elna_rtl_symbol_table(symbol_table: ^ElnaSymbolTable); +proc elna_rtl_symbol_table(symbol_table: ^ElnaSymbolTable) -> ^ElnaSymbolTable; var variable_map: ^ElnaSymbolTable; count: Word; @@ -3867,7 +3891,7 @@ begin return variable_map; end; -proc elna_rtl_procedure_declaration(tac_declaration: ^ElnaTacProcedure); +proc elna_rtl_procedure_declaration(tac_declaration: ^ElnaTacProcedure) -> ^ElnaRtlProcedure; var result: ^ElnaRtlProcedure; begin @@ -3887,7 +3911,7 @@ begin return result end; -proc elna_tac_procedure_declaration(parser_node: ^ElnaTreeProcedureDeclaration); +proc elna_tac_procedure_declaration(parser_node: ^ElnaTreeProcedureDeclaration) -> ^ElnaTacProcedure; var symbol_info: ^ElnaSymbolProcedureInfo; result: ^ElnaTacProcedure; @@ -3943,7 +3967,7 @@ begin return result end; -proc elna_rtl_globals(tac_procedure: ^ElnaTacStaticVariable); +proc elna_rtl_globals(tac_procedure: ^ElnaTacStaticVariable) -> ^ElnaRtlStaticVariable; var current_copy: ^ElnaRtlStaticVariable; next_copy: ^ElnaRtlStaticVariable; @@ -3971,7 +3995,7 @@ begin return first_copy end; -proc elna_rtl_procedures(tac_procedure: ^ElnaTacProcedure); +proc elna_rtl_procedures(tac_procedure: ^ElnaTacProcedure) -> ^ElnaRtlProcedure; var current_copy: ^ElnaRtlProcedure; next_copy: ^ElnaRtlProcedure; @@ -4043,7 +4067,7 @@ begin end end; -proc elna_parser_type_declaration(cursor: ^ElnaLexerCursor); +proc elna_parser_type_declaration(cursor: ^ElnaLexerCursor) -> ^ElnaTreeTypeDeclaration; var result: ^ElnaTreeTypeDeclaration; token: ^ElnaLexerToken; @@ -4066,25 +4090,20 @@ end; proc elna_name_type_declaration(parser_node: ^ElnaTreeTypeDeclaration); var - type_name: Word; - name_length: Word; - type_info: Word; + symbol_type: ^ElnaType; + type_info: ^ElnaSymbolTypeInfo; begin - type_name := parser_node^.name; - name_length := parser_node^.length; + symbol_type := elna_name_type_expression(parser_node^._type); + type_info := type_info_create(symbol_type); - parser_node := parser_node^._type; - type_info := elna_name_type_expression(parser_node); - type_info := type_info_create(type_info); - - elna_symbol_table_enter(@symbol_table_global, type_name, name_length, type_info) + elna_symbol_table_enter(@symbol_table_global, parser_node^.name, parser_node^.length, type_info) end; proc elna_type_type_declaration(parser_node: Word); begin end; -proc elna_parser_type_part(cursor: ^ElnaLexerCursor); +proc elna_parser_type_part(cursor: ^ElnaLexerCursor) -> ^ElnaTreeDeclaration; var parser_node: ^ElnaTreeDeclaration; result: ^ElnaTreeDeclaration; @@ -4120,7 +4139,7 @@ begin return result end; -proc elna_parser_variable_declaration(cursor: ^ElnaLexerCursor); +proc elna_parser_variable_declaration(cursor: ^ElnaLexerCursor) -> ^ElnaTreeVariableDeclaration; var variable_type: Word; result: ^ElnaTreeVariableDeclaration; @@ -4143,7 +4162,7 @@ begin return result end; -proc elna_tac_variable_declaration(parser_tree: ^ElnaTreeVariableDeclaration); +proc elna_tac_variable_declaration(parser_tree: ^ElnaTreeVariableDeclaration) -> ^ElnaTacStaticVariable; var result: ^ElnaTacStaticVariable; variable_info: ^ElnaSymbolTemporaryInfo; @@ -4159,14 +4178,14 @@ begin return result end; -proc elna_parser_var_part(cursor: ^ElnaLexerCursor); +proc elna_parser_var_part(cursor: ^ElnaLexerCursor) -> ^ElnaTreeDeclaration; var - result: Word; - variable_node: Word; + result: ^ElnaTreeDeclaration; + variable_node: ^ElnaTreeDeclaration; current_declaration: ^ElnaTreeDeclaration; token: ^ElnaLexerToken; begin - result := 0; + result := nil; token := elna_lexer_peek(cursor); if token^.kind <> ElnaLexerKind._var then @@ -4185,7 +4204,7 @@ begin (* Skip semicolon. *) elna_lexer_read(cursor); - if result = 0 then + if result = nil then result := variable_node else current_declaration^.next := variable_node @@ -4198,20 +4217,20 @@ begin return result end; -proc elna_tac_var_part(parser_node: ^ElnaTreeDeclaration); +proc elna_tac_var_part(parser_node: ^ElnaTreeDeclaration) -> ^ElnaTacStaticVariable; var node: ^ElnaTacStaticVariable; current_variable: ^ElnaTacStaticVariable; first_variable: ^ElnaTacStaticVariable; begin - first_variable := 0; - if parser_node = 0 then + first_variable := nil; + if parser_node = nil 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 + if first_variable = nil then first_variable := node else current_variable^.next := node @@ -4219,7 +4238,7 @@ begin current_variable := node; parser_node := parser_node^.next; - if parser_node <> 0 then + if parser_node <> nil then goto elna_tac_var_part_loop end; @@ -4273,7 +4292,7 @@ begin return result end; -proc elna_tac_program_body(parser_node: ^ElnaTreeStatement); +proc elna_tac_program_body(parser_node: ^ElnaTreeStatement) -> ^ElnaTacProcedure; var result: ^ElnaTacProcedure; symbol_info: ^ElnaSymbolProcedureInfo; @@ -4298,7 +4317,7 @@ begin return result end; -proc elna_tac_module_declaration(parser_node: ^ElnaTreeModuleDeclaration); +proc elna_tac_module_declaration(parser_node: ^ElnaTreeModuleDeclaration) -> ^ElnaInstructionModule; var result: ^ElnaInstructionModule; code: ^ElnaTacProcedure;