Collect declarations before doing name analysis
This commit is contained in:
+260
-164
@@ -3,11 +3,15 @@
|
||||
* 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 23 compiler. *)
|
||||
|
||||
(* - Support extern procedure declarations. *)
|
||||
(* - Do not require program keyword in the beginning of a module. *)
|
||||
(* - Support records refencing themselves in their fields. *)
|
||||
(* - Types can be referenced even if they are declared later. *)
|
||||
|
||||
type
|
||||
ElnaListNode = record
|
||||
@@ -35,12 +39,18 @@ type
|
||||
end
|
||||
|
||||
(* Type representation. *)
|
||||
ElnaTypeKind = (primitive, enumeration, _record, pointer, array)
|
||||
ElnaTypeKind = (primitive, enumeration, _record, pointer, array, alias)
|
||||
ElnaType = record
|
||||
kind: ElnaTypeKind;
|
||||
size: Word;
|
||||
alignment: Word
|
||||
end
|
||||
ElnaTypeAlias = record
|
||||
kind: ElnaTypeKind;
|
||||
size: Word;
|
||||
alignment: Word;
|
||||
base: ^ElnaType
|
||||
end
|
||||
ElnaTypeEnumeration = record
|
||||
kind: ElnaTypeKind;
|
||||
size: Word;
|
||||
@@ -333,7 +343,8 @@ type
|
||||
ElnaSymbolProcedureInfo = record
|
||||
kind: ElnaSymbolInfoKind;
|
||||
symbol_table: ^ElnaSymbolTable;
|
||||
return_type: ^ElnaType
|
||||
return_type: ^ElnaType;
|
||||
is_extern: Bool
|
||||
end
|
||||
|
||||
ElnaLexerAction = (none, accumulate, skip, single, eof, finalize, composite, key_id, integer, delimited)
|
||||
@@ -865,7 +876,7 @@ begin
|
||||
operand^.value := buffer;
|
||||
operand^.length := strlen(buffer);
|
||||
|
||||
temporary_info := temporary_info_create(1, variable_type);
|
||||
temporary_info := elna_symbol_temporary_info_create(1, variable_type);
|
||||
elna_symbol_table_enter(symbol_table, buffer, operand^.length, temporary_info)
|
||||
end
|
||||
|
||||
@@ -3897,15 +3908,13 @@ end
|
||||
*
|
||||
* Returns enumeration type description.
|
||||
*)
|
||||
proc elna_name_enumeration_type_expression(parser_node: ^ElnaTreeEnumerationTypeExpression) -> ^ElnaTypeEnumeration
|
||||
proc elna_name_enumeration_type_expression(parser_node: ^ElnaTreeEnumerationTypeExpression,
|
||||
result: ^ElnaTypeEnumeration)
|
||||
var
|
||||
result: ^ElnaTypeEnumeration
|
||||
memory_start: ^ElnaTreeEnumeration
|
||||
member_count: Word
|
||||
member_array_current: ^String
|
||||
begin
|
||||
result := malloc(#size(ElnaTypeEnumeration));
|
||||
|
||||
memory_start := parser_node^.members;
|
||||
member_count := parser_node^.length;
|
||||
|
||||
@@ -3922,58 +3931,43 @@ begin
|
||||
member_count := member_count - 1;
|
||||
goto elna_name_type_enumeration_loop
|
||||
end;
|
||||
|
||||
result^.kind := ElnaTypeKind.enumeration;
|
||||
result^.size := 4;
|
||||
result^.alignment := 4;
|
||||
result^.length := parser_node^.length;
|
||||
|
||||
return result
|
||||
result^.length := parser_node^.length
|
||||
end
|
||||
|
||||
proc elna_name_pointer_type_expression(parser_node: ^ElnaTreePointerTypeExpression) -> ^ElnaTypePointer
|
||||
var
|
||||
result: ^ElnaTypePointer
|
||||
proc elna_name_pointer_type_expression(parser_node: ^ElnaTreePointerTypeExpression,
|
||||
result: ^ElnaTypePointer)
|
||||
begin
|
||||
result := malloc(#size(ElnaTypePointer));
|
||||
|
||||
result^.kind := ElnaTypeKind.pointer;
|
||||
result^.size := 4;
|
||||
result^.alignment := 4;
|
||||
result^.base := elna_name_type_expression(parser_node^.base);
|
||||
|
||||
return result
|
||||
result^.base := elna_name_type_expression(parser_node^.base)
|
||||
end
|
||||
|
||||
proc elna_name_array_type_expression(parser_node: ^ElnaTreeArrayTypeExpression) -> ^ElnaTypeArray
|
||||
proc elna_name_array_type_expression(parser_node: ^ElnaTreeArrayTypeExpression,
|
||||
result: ^ElnaTypeArray)
|
||||
var
|
||||
base: ^ElnaType
|
||||
result: ^ElnaTypeArray
|
||||
length: ^ElnaTreeIntegerLiteral
|
||||
begin
|
||||
result := malloc(#size(ElnaTypeArray));
|
||||
base := elna_name_type_expression(parser_node^.base);
|
||||
length := parser_node^.length;
|
||||
|
||||
result^.kind := ElnaTypeKind.array;
|
||||
(* Array size in bytes. *)
|
||||
result^.size := base^.size * length^.value;
|
||||
result^.alignment := base^.alignment;
|
||||
result^.base := base;
|
||||
result^.length := length^.value;
|
||||
|
||||
return result
|
||||
result^.length := length^.value
|
||||
end
|
||||
|
||||
proc elna_name_record_type_expression(parser_node: ^ElnaTreeRecordTypeExpression) -> ^ElnaTypeRecord
|
||||
proc elna_name_record_type_expression(parser_node: ^ElnaTreeRecordTypeExpression,
|
||||
result: ^ElnaTypeRecord)
|
||||
var
|
||||
result: ^ElnaTypeRecord
|
||||
tree_field: ^ElnaTreeField
|
||||
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;
|
||||
@@ -3998,9 +3992,7 @@ begin
|
||||
tree_field := tree_field^.next;
|
||||
result^.length := result^.length + 1;
|
||||
goto elna_name_type_record_loop
|
||||
end;
|
||||
|
||||
return result
|
||||
end
|
||||
end
|
||||
|
||||
proc elna_parser_named_type_expression(cursor: ^ElnaLexerCursor) -> ^ElnaTreeNamedTypeExpression
|
||||
@@ -4091,7 +4083,21 @@ begin
|
||||
return result
|
||||
end
|
||||
|
||||
proc elna_name_type_expression(parser_node: ^ElnaTreeNode) -> ^ElnaType
|
||||
proc elna_name_alias_type_expression(parser_node: ^ElnaTreeNamedTypeExpression, result: ^ElnaTypeAlias)
|
||||
var
|
||||
type_symbol: ^ElnaSymbolTypeInfo
|
||||
aliased_type: ^ElnaType
|
||||
begin
|
||||
type_symbol := elna_symbol_table_lookup(symbol_table_global,
|
||||
parser_node^.name.ptr, parser_node^.name.length);
|
||||
aliased_type := type_symbol^._type;
|
||||
|
||||
result^.size := aliased_type^.size;
|
||||
result^.alignment := aliased_type^.alignment;
|
||||
result^.base := aliased_type
|
||||
end
|
||||
|
||||
proc elna_name_type_expression(parser_node: ^ElnaTreeTypeExpression) -> ^ElnaType
|
||||
var
|
||||
named_type_expression: ^ElnaTreeNamedTypeExpression
|
||||
type_symbol: ^ElnaSymbolTypeInfo
|
||||
@@ -4104,19 +4110,31 @@ begin
|
||||
named_type_expression^.name.ptr, named_type_expression^.name.length);
|
||||
result := type_symbol^._type
|
||||
elsif parser_node^.kind = ElnaTreeKind.enumeration_type_expression then
|
||||
result := elna_name_enumeration_type_expression(parser_node)
|
||||
result := malloc(#size(ElnaTypeEnumeration));
|
||||
result^.kind := ElnaTypeKind.enumeration;
|
||||
|
||||
elna_name_enumeration_type_expression(parser_node, result)
|
||||
elsif parser_node^.kind = ElnaTreeKind.record_type_expression then
|
||||
result := elna_name_record_type_expression(parser_node)
|
||||
result := malloc(#size(ElnaTypeRecord));
|
||||
result^.kind := ElnaTypeKind._record;
|
||||
|
||||
elna_name_record_type_expression(parser_node, result)
|
||||
elsif parser_node^.kind = ElnaTreeKind.pointer_type_expression then
|
||||
result := elna_name_pointer_type_expression(parser_node)
|
||||
result := malloc(#size(ElnaTypePointer));
|
||||
result^.kind := ElnaTypeKind.pointer;
|
||||
|
||||
elna_name_pointer_type_expression(parser_node, result)
|
||||
elsif parser_node^.kind = ElnaTreeKind.array_type_expression then
|
||||
result := elna_name_array_type_expression(parser_node)
|
||||
result := malloc(#size(ElnaTypeArray));
|
||||
result^.kind := ElnaTypeKind.array;
|
||||
|
||||
elna_name_array_type_expression(parser_node, result)
|
||||
end;
|
||||
|
||||
return result
|
||||
end
|
||||
|
||||
proc type_info_create(type_representation: ^ElnaType) -> ^ElnaSymbolTypeInfo
|
||||
proc elna_symbol_type_info_create(type_representation: ^ElnaType) -> ^ElnaSymbolTypeInfo
|
||||
var
|
||||
result: ^ElnaSymbolTypeInfo
|
||||
begin
|
||||
@@ -4132,7 +4150,7 @@ end
|
||||
* attr - Local variable attributes.
|
||||
* temporary_type - Local variable type.
|
||||
*)
|
||||
proc temporary_info_create(attr: Word, temporary_type: ^ElnaType) -> ^ElnaSymbolTemporaryInfo
|
||||
proc elna_symbol_temporary_info_create(attr: Word, temporary_type: ^ElnaType) -> ^ElnaSymbolTemporaryInfo
|
||||
var
|
||||
result: ^ElnaSymbolTemporaryInfo
|
||||
begin
|
||||
@@ -4150,14 +4168,14 @@ end
|
||||
* Parameters:
|
||||
* symbol_table - Local symbol table.
|
||||
*)
|
||||
proc procedure_info_create(symbol_table: ^ElnaSymbolTable, return_type: ^ElnaRtlType) -> ^ElnaSymbolProcedureInfo
|
||||
proc elna_symbol_procedure_info_create(return_type: ^ElnaRtlType, is_extern: Bool) -> ^ElnaSymbolProcedureInfo
|
||||
var
|
||||
result: ^ElnaSymbolProcedureInfo
|
||||
begin
|
||||
result := malloc(#size(ElnaSymbolProcedureInfo));
|
||||
result^.kind := ElnaSymbolInfoKind.procedure_info;
|
||||
result^.symbol_table := symbol_table;
|
||||
result^.return_type := return_type;
|
||||
result^.is_extern := is_extern;
|
||||
|
||||
return result
|
||||
end
|
||||
@@ -4168,12 +4186,12 @@ end
|
||||
*)
|
||||
proc elna_name_procedure_temporary(parser_node: ^ElnaTreeVariableDeclaration, symbol_table: ^ElnaSymbolTable)
|
||||
var
|
||||
info: Word
|
||||
variable_type: Word
|
||||
info: ^ElnaSymbolTemporaryInfo
|
||||
variable_type: ^ElnaType
|
||||
begin
|
||||
variable_type := elna_name_type_expression(parser_node^.type_expression);
|
||||
|
||||
info := temporary_info_create(0, variable_type);
|
||||
info := elna_symbol_temporary_info_create(0, variable_type);
|
||||
elna_symbol_table_enter(symbol_table, parser_node^.name.ptr, parser_node^.name.length, info)
|
||||
end
|
||||
|
||||
@@ -4725,17 +4743,25 @@ end
|
||||
|
||||
proc elna_name_type_declaration(parser_node: ^ElnaTreeTypeDeclaration)
|
||||
var
|
||||
symbol_type: ^ElnaType
|
||||
type_info: ^ElnaSymbolTypeInfo
|
||||
type_stub: ^ElnaType
|
||||
type_expression: ^ElnaTreeTypeExpression
|
||||
begin
|
||||
symbol_type := elna_name_type_expression(parser_node^.type_expression);
|
||||
type_info := type_info_create(symbol_type);
|
||||
type_info := elna_symbol_table_lookup(symbol_table_global, parser_node^.name.ptr, parser_node^.name.length);
|
||||
type_stub := type_info^._type;
|
||||
type_expression := parser_node^.type_expression;
|
||||
|
||||
elna_symbol_table_enter(symbol_table_global, parser_node^.name.ptr, parser_node^.name.length, type_info)
|
||||
end
|
||||
|
||||
proc elna_type_type_declaration(parser_node: Word)
|
||||
begin
|
||||
if type_stub^.kind = ElnaTypeKind.alias then
|
||||
elna_name_alias_type_expression(type_expression, type_stub)
|
||||
elsif type_stub^.kind = ElnaTypeKind.enumeration then
|
||||
elna_name_enumeration_type_expression(type_expression, type_stub)
|
||||
elsif type_stub^.kind = ElnaTypeKind._record then
|
||||
elna_name_record_type_expression(type_expression, type_stub)
|
||||
elsif type_stub^.kind = ElnaTypeKind.pointer then
|
||||
elna_name_pointer_type_expression(type_expression, type_stub)
|
||||
elsif type_stub^.kind = ElnaTypeKind.array then
|
||||
elna_name_array_type_expression(type_expression, type_stub)
|
||||
end
|
||||
end
|
||||
|
||||
proc elna_parser_type_part(cursor: ^ElnaLexerCursor, error_list: ^ElnaList) -> ^ElnaTreeDeclaration
|
||||
@@ -4935,37 +4961,40 @@ end
|
||||
|
||||
proc elna_parser_module_declaration(cursor: ^ElnaLexerCursor, error_list: ^ElnaList) -> ^ElnaTreeModuleDeclaration
|
||||
var
|
||||
token: ^ElnaLexerToken
|
||||
result: ^ElnaTreeModuleDeclaration
|
||||
begin
|
||||
result := nil;
|
||||
if elna_parser_expect(cursor, ElnaLexerKind._program, error_list) <> nil then
|
||||
if elna_parser_expect(cursor, ElnaLexerKind.semicolon, error_list) <> nil then
|
||||
result := malloc(#size(ElnaTreeModuleDeclaration));
|
||||
result^.kind := ElnaTreeKind.module_declaration;
|
||||
elna_lexer_skip_empty_lines(cursor);
|
||||
token := elna_lexer_peek(cursor);
|
||||
if token^.kind = ElnaLexerKind._program then
|
||||
elna_lexer_read(cursor);
|
||||
elna_lexer_read(cursor)
|
||||
end;
|
||||
|
||||
result^.types := elna_parser_type_part(cursor, error_list);
|
||||
if elna_list_empty(error_list) = false then
|
||||
result := free_and_nil(result)
|
||||
end;
|
||||
if result <> nil then
|
||||
result^.globals := elna_parser_var_part(cursor, error_list);
|
||||
end;
|
||||
if elna_list_empty(error_list) = false then
|
||||
result := free_and_nil(result)
|
||||
end;
|
||||
if result <> nil then
|
||||
result^.procedures := elna_parser_procedures(cursor, error_list);
|
||||
end;
|
||||
if elna_list_empty(error_list) = false then
|
||||
result := free_and_nil(result)
|
||||
end;
|
||||
if result <> nil then
|
||||
result^.body := elna_parser_program_body(cursor, error_list)
|
||||
end;
|
||||
if elna_list_empty(error_list) = false then
|
||||
result := free_and_nil(result)
|
||||
end
|
||||
end
|
||||
result := malloc(#size(ElnaTreeModuleDeclaration));
|
||||
result^.kind := ElnaTreeKind.module_declaration;
|
||||
|
||||
result^.types := elna_parser_type_part(cursor, error_list);
|
||||
if elna_list_empty(error_list) = false then
|
||||
result := free_and_nil(result)
|
||||
end;
|
||||
if result <> nil then
|
||||
result^.globals := elna_parser_var_part(cursor, error_list);
|
||||
end;
|
||||
if elna_list_empty(error_list) = false then
|
||||
result := free_and_nil(result)
|
||||
end;
|
||||
if result <> nil then
|
||||
result^.procedures := elna_parser_procedures(cursor, error_list);
|
||||
end;
|
||||
if elna_list_empty(error_list) = false then
|
||||
result := free_and_nil(result)
|
||||
end;
|
||||
if result <> nil then
|
||||
result^.body := elna_parser_program_body(cursor, error_list)
|
||||
end;
|
||||
if elna_list_empty(error_list) = false then
|
||||
result := free_and_nil(result)
|
||||
end;
|
||||
return result
|
||||
end
|
||||
@@ -5022,90 +5051,104 @@ begin
|
||||
return result
|
||||
end
|
||||
|
||||
proc elna_name_dereference_expression(parser_node: ^ElnaTreeDereferenceExpression)
|
||||
proc elna_name_dereference_expression(parser_node: ^ElnaTreeDereferenceExpression, symbol_table: ^ElnaSymbolTable)
|
||||
begin
|
||||
elna_name_designator(parser_node^.pointer)
|
||||
elna_name_designator(parser_node^.pointer, symbol_table)
|
||||
end
|
||||
|
||||
proc elna_name_field_access_expression(parser_node: ^ElnaTreeFieldAccessExpression)
|
||||
proc elna_name_field_access_expression(parser_node: ^ElnaTreeFieldAccessExpression, symbol_table: ^ElnaSymbolTable)
|
||||
begin
|
||||
elna_name_designator(parser_node^.aggregate)
|
||||
elna_name_designator(parser_node^.aggregate, symbol_table)
|
||||
end
|
||||
|
||||
proc elna_name_array_access_expression(parser_node: ^ElnaTreeArrayAccessExpression)
|
||||
proc elna_name_array_access_expression(parser_node: ^ElnaTreeArrayAccessExpression, symbol_table: ^ElnaSymbolTable)
|
||||
begin
|
||||
elna_name_designator(parser_node^.array);
|
||||
elna_name_binary_expression(parser_node^.index)
|
||||
elna_name_designator(parser_node^.array, symbol_table);
|
||||
elna_name_binary_expression(parser_node^.index, symbol_table)
|
||||
end
|
||||
|
||||
proc elna_name_cast_expression(parser_node: ^ElnaTreeCastExpression)
|
||||
proc elna_name_cast_expression(parser_node: ^ElnaTreeCastExpression, symbol_table: ^ElnaSymbolTable)
|
||||
begin
|
||||
elna_name_binary_expression(parser_node^.expression);
|
||||
parser_node^.type_decoration := elna_name_type_expression(parser_node^.type_expression)
|
||||
end
|
||||
|
||||
proc elna_name_simple_expression(parser_node: ^ElnaTreeNode)
|
||||
proc elna_name_variable_expression(parser_node: ^ElnaTreeVariableExpression, symbol_table: ^ElnaSymbolTable)
|
||||
begin
|
||||
(* Not interested in literals and variable expressions. *)
|
||||
end
|
||||
|
||||
proc elna_name_simple_expression(parser_node: ^ElnaTreeNode, symbol_table: ^ElnaSymbolTable)
|
||||
begin
|
||||
(* Not interested in literals. *)
|
||||
if parser_node^.kind = ElnaTreeKind._cast then
|
||||
elna_name_cast_expression(parser_node)
|
||||
elna_name_cast_expression(parser_node, symbol_table)
|
||||
elsif parser_node^.kind = ElnaTreeKind.variable_expression then
|
||||
elna_name_variable_expression(parser_node, symbol_table)
|
||||
end
|
||||
end
|
||||
|
||||
proc elna_name_call(parser_node: ^ElnaTreeCall)
|
||||
proc elna_name_call(parser_node: ^ElnaTreeCall, symbol_table: ^ElnaSymbolTable)
|
||||
var
|
||||
argument_tree: ^ElnaTreeExpressionList
|
||||
callee_symbol: ^ElnaSymbolProcedureInfo
|
||||
begin
|
||||
callee_symbol := elna_symbol_table_lookup(symbol_table_global, parser_node^.callee^.name.ptr, parser_node^.callee^.name.length);
|
||||
if callee_symbol = nil then
|
||||
(* DEBUG *)
|
||||
_write_s(stdout, "# Undefined symbol ");
|
||||
_write_s(stdout, parser_node^.callee^.name);
|
||||
_write_s(stdout, ".\n")
|
||||
end;
|
||||
argument_tree := parser_node^.arguments;
|
||||
|
||||
.elna_name_call_argument;
|
||||
if argument_tree <> nil then
|
||||
elna_name_binary_expression(argument_tree^.expression);
|
||||
elna_name_binary_expression(argument_tree^.expression, symbol_table);
|
||||
argument_tree := argument_tree^.next;
|
||||
|
||||
goto elna_name_call_argument
|
||||
end
|
||||
end
|
||||
|
||||
proc elna_name_designator(parser_node: ^ElnaTreeNode)
|
||||
proc elna_name_designator(parser_node: ^ElnaTreeNode, symbol_table: ^ElnaSymbolTable)
|
||||
begin
|
||||
if parser_node^.kind = ElnaTreeKind.dereference_expression then
|
||||
elna_name_dereference_expression(parser_node)
|
||||
elna_name_dereference_expression(parser_node, symbol_table)
|
||||
elsif parser_node^.kind = ElnaTreeKind.field_access_expression then
|
||||
elna_name_field_access_expression(parser_node)
|
||||
elna_name_field_access_expression(parser_node, symbol_table)
|
||||
elsif parser_node^.kind = ElnaTreeKind.array_access_expression then
|
||||
elna_name_array_access_expression(parser_node)
|
||||
elna_name_array_access_expression(parser_node, symbol_table)
|
||||
elsif parser_node^.kind = ElnaTreeKind.call then
|
||||
elna_name_call(parser_node)
|
||||
elna_name_call(parser_node, symbol_table)
|
||||
else
|
||||
elna_name_simple_expression(parser_node)
|
||||
elna_name_simple_expression(parser_node, symbol_table)
|
||||
end
|
||||
end
|
||||
|
||||
proc elna_name_unary_expression(parser_node: ^ElnaTreeUnaryExpression)
|
||||
proc elna_name_unary_expression(parser_node: ^ElnaTreeUnaryExpression, symbol_table: ^ElnaSymbolTable)
|
||||
begin
|
||||
if parser_node^.kind = ElnaTreeKind.unary_expression then
|
||||
elna_name_designator(parser_node^.operand)
|
||||
elna_name_designator(parser_node^.operand, symbol_table)
|
||||
else
|
||||
elna_name_designator(parser_node)
|
||||
elna_name_designator(parser_node, symbol_table)
|
||||
end
|
||||
end
|
||||
|
||||
proc elna_name_binary_expression(parser_node: ^ElnaTreeBinaryExpression)
|
||||
proc elna_name_binary_expression(parser_node: ^ElnaTreeBinaryExpression, symbol_table: ^ElnaSymbolTable)
|
||||
begin
|
||||
if parser_node^.kind = ElnaTreeKind.binary_expression then
|
||||
elna_name_unary_expression(parser_node^.lhs);
|
||||
elna_name_unary_expression(parser_node^.rhs)
|
||||
elna_name_unary_expression(parser_node^.lhs, symbol_table);
|
||||
elna_name_unary_expression(parser_node^.rhs, symbol_table)
|
||||
else
|
||||
elna_name_unary_expression(parser_node)
|
||||
elna_name_unary_expression(parser_node, symbol_table)
|
||||
end
|
||||
end
|
||||
|
||||
proc elna_name_conditional_statements(parser_node: ^ElnaTreeConditionalStatements)
|
||||
proc elna_name_conditional_statements(parser_node: ^ElnaTreeConditionalStatements, symbol_table: ^ElnaSymbolTable)
|
||||
begin
|
||||
.elna_name_conditional_statements_loop;
|
||||
elna_name_binary_expression(parser_node^.condition);
|
||||
elna_name_statements(parser_node^.statements);
|
||||
elna_name_binary_expression(parser_node^.condition, symbol_table);
|
||||
elna_name_statements(parser_node^.statements, symbol_table);
|
||||
|
||||
parser_node := parser_node^.next;
|
||||
if parser_node <> nil then
|
||||
@@ -5113,14 +5156,14 @@ begin
|
||||
end
|
||||
end
|
||||
|
||||
proc elna_name_if_statement(parser_node: ^ElnaTreeIfStatement)
|
||||
proc elna_name_if_statement(parser_node: ^ElnaTreeIfStatement, symbol_table: ^ElnaSymbolTable)
|
||||
var
|
||||
block: ^ElnaTreeConditionalStatements
|
||||
begin
|
||||
block := parser_node^.conditionals;
|
||||
|
||||
.elna_name_if_statement_conditionals;
|
||||
elna_name_conditional_statements(block);
|
||||
elna_name_conditional_statements(block, symbol_table);
|
||||
|
||||
block := block^.next;
|
||||
if block <> nil then
|
||||
@@ -5128,40 +5171,40 @@ begin
|
||||
end;
|
||||
block := parser_node^._else;
|
||||
if block <> nil then
|
||||
elna_name_statements(block)
|
||||
elna_name_statements(block, symbol_table)
|
||||
end
|
||||
end
|
||||
|
||||
proc elna_name_return_statement(parser_node: ^ElnaTreeReturnStatement)
|
||||
proc elna_name_return_statement(parser_node: ^ElnaTreeReturnStatement, symbol_table: ^ElnaSymbolTable)
|
||||
begin
|
||||
elna_name_binary_expression(parser_node^.returned)
|
||||
elna_name_binary_expression(parser_node^.returned, symbol_table)
|
||||
end
|
||||
|
||||
proc elna_name_assign_statement(parser_node: ^ElnaTreeAssignStatement)
|
||||
proc elna_name_assign_statement(parser_node: ^ElnaTreeAssignStatement, symbol_table: ^ElnaSymbolTable)
|
||||
begin
|
||||
elna_name_designator(parser_node^.assignee);
|
||||
elna_name_binary_expression(parser_node^.assignment)
|
||||
elna_name_designator(parser_node^.assignee, symbol_table);
|
||||
elna_name_binary_expression(parser_node^.assignment, symbol_table)
|
||||
end
|
||||
|
||||
proc elna_name_statement(parser_node: ^ElnaTreeStatement)
|
||||
proc elna_name_statement(parser_node: ^ElnaTreeStatement, symbol_table: ^ElnaSymbolTable)
|
||||
begin
|
||||
(* Skipping goto and label declarations. *)
|
||||
if parser_node^.kind = ElnaTreeKind.if_statement then
|
||||
elna_name_if_statement(parser_node)
|
||||
elna_name_if_statement(parser_node, symbol_table)
|
||||
elsif parser_node^.kind = ElnaTreeKind.return_statement then
|
||||
elna_name_return_statement(parser_node)
|
||||
elna_name_return_statement(parser_node, symbol_table)
|
||||
elsif parser_node^.kind = ElnaTreeKind.call then
|
||||
elna_name_call(parser_node)
|
||||
elna_name_call(parser_node, symbol_table)
|
||||
elsif parser_node^.kind = ElnaTreeKind.assign_statement then
|
||||
elna_name_assign_statement(parser_node)
|
||||
elna_name_assign_statement(parser_node, symbol_table)
|
||||
end
|
||||
end
|
||||
|
||||
proc elna_name_statements(parser_node: ^ElnaTreeStatement)
|
||||
proc elna_name_statements(parser_node: ^ElnaTreeStatement, symbol_table: ^ElnaSymbolTable)
|
||||
begin
|
||||
.elna_name_statements_loop;
|
||||
if parser_node <> nil then
|
||||
elna_name_statement(parser_node);
|
||||
elna_name_statement(parser_node, symbol_table);
|
||||
|
||||
parser_node := parser_node^.next;
|
||||
goto elna_name_statements_loop
|
||||
@@ -5174,28 +5217,23 @@ var
|
||||
symbol_info: ^ElnaSymbolProcedureInfo
|
||||
return_type: ^ElnaType
|
||||
begin
|
||||
if parser_node^.return_type = nil then
|
||||
return_type := nil
|
||||
else
|
||||
return_type := elna_name_type_expression(parser_node^.return_type);
|
||||
end;
|
||||
new_symbol_table := elna_symbol_table_create(symbol_table_global);
|
||||
symbol_info := procedure_info_create(new_symbol_table, return_type);
|
||||
symbol_info := elna_symbol_table_lookup(symbol_table_global, parser_node^.name.ptr, parser_node^.name.length);
|
||||
if symbol_info^.is_extern = false then
|
||||
new_symbol_table := elna_symbol_table_create(symbol_table_global);
|
||||
symbol_info^.symbol_table := new_symbol_table;
|
||||
|
||||
elna_name_procedure_temporaries(parser_node^.parameters, new_symbol_table);
|
||||
elna_name_procedure_temporaries(parser_node^.temporaries, new_symbol_table);
|
||||
elna_name_statements(parser_node^.body);
|
||||
|
||||
elna_symbol_table_enter(symbol_table_global, parser_node^.name.ptr, parser_node^.name.length, symbol_info)
|
||||
elna_name_procedure_temporaries(parser_node^.parameters, new_symbol_table);
|
||||
elna_name_procedure_temporaries(parser_node^.temporaries, new_symbol_table);
|
||||
elna_name_statements(parser_node^.body, new_symbol_table)
|
||||
end
|
||||
end
|
||||
|
||||
proc elna_name_program_body(parser_node: ^ElnaTreeStatement)
|
||||
var
|
||||
new_symbol_table: ^ElnaSymbolTable
|
||||
symbol_info: Word
|
||||
symbol_info: ^ElnaSymbolProcedureInfo
|
||||
begin
|
||||
new_symbol_table := elna_symbol_table_create(symbol_table_global);
|
||||
symbol_info := procedure_info_create(new_symbol_table);
|
||||
symbol_info := elna_symbol_procedure_info_create(nil, false);
|
||||
symbol_info^.symbol_table := elna_symbol_table_create(symbol_table_global);
|
||||
|
||||
elna_symbol_table_enter(symbol_table_global, "main".ptr, 4, symbol_info)
|
||||
end
|
||||
@@ -5514,15 +5552,6 @@ 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 <> nil 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 <> nil then
|
||||
@@ -5533,6 +5562,74 @@ begin
|
||||
end
|
||||
end
|
||||
|
||||
proc elna_declaration_type_declaration(parser_node: ^ElnaTreeTypeDeclaration)
|
||||
var
|
||||
type_info: ^ElnaSymbolTypeInfo
|
||||
result: ^ElnaType
|
||||
type_expression: ^ElnaTreeTypeExpression
|
||||
begin
|
||||
type_expression := parser_node^.type_expression;
|
||||
|
||||
if type_expression^.kind = ElnaTreeKind.named_type_expression then
|
||||
result := malloc(#size(ElnaTypeAlias));
|
||||
result^.kind := ElnaTypeKind.alias
|
||||
elsif type_expression^.kind = ElnaTreeKind.enumeration_type_expression then
|
||||
result := malloc(#size(ElnaTypeEnumeration));
|
||||
result^.kind := ElnaTypeKind.enumeration
|
||||
elsif type_expression^.kind = ElnaTreeKind.record_type_expression then
|
||||
result := malloc(#size(ElnaTypeRecord));
|
||||
result^.kind := ElnaTypeKind._record
|
||||
elsif type_expression^.kind = ElnaTreeKind.pointer_type_expression then
|
||||
result := malloc(#size(ElnaTypePointer));
|
||||
result^.kind := ElnaTypeKind.pointer
|
||||
elsif type_expression^.kind = ElnaTreeKind.array_type_expression then
|
||||
result := malloc(#size(ElnaTypeArray));
|
||||
result^.kind := ElnaTypeKind.array
|
||||
end;
|
||||
type_info := elna_symbol_type_info_create(result);
|
||||
|
||||
elna_symbol_table_enter(symbol_table_global, parser_node^.name.ptr, parser_node^.name.length, type_info)
|
||||
end
|
||||
|
||||
proc elna_declaration_procedure_declaration(parser_node: ^ElnaTreeProcedureDeclaration)
|
||||
var
|
||||
symbol_info: ^ElnaSymbolProcedureInfo
|
||||
return_type: ^ElnaType
|
||||
begin
|
||||
if parser_node^.return_type = nil then
|
||||
return_type := nil
|
||||
else
|
||||
return_type := elna_name_type_expression(parser_node^.return_type);
|
||||
end;
|
||||
symbol_info := elna_symbol_procedure_info_create(return_type, parser_node^.is_extern);
|
||||
symbol_info^.symbol_table := elna_symbol_table_create(symbol_table_global);
|
||||
|
||||
elna_symbol_table_enter(symbol_table_global, parser_node^.name.ptr, parser_node^.name.length, symbol_info)
|
||||
end
|
||||
|
||||
proc elna_declaration_module_declaration(parser_node: ^ElnaTreeModuleDeclaration)
|
||||
var
|
||||
current_part: ^ElnaTreeDeclaration
|
||||
begin
|
||||
current_part := parser_node^.types;
|
||||
.elna_declaration_module_declaration_type;
|
||||
if current_part <> nil then
|
||||
elna_declaration_type_declaration(current_part);
|
||||
current_part := current_part^.next;
|
||||
|
||||
goto elna_declaration_module_declaration_type
|
||||
end;
|
||||
|
||||
current_part := parser_node^.procedures;
|
||||
.elna_declaration_module_declaration_procedure;
|
||||
if current_part <> nil then
|
||||
elna_declaration_procedure_declaration(current_part);
|
||||
current_part := current_part^.next;
|
||||
|
||||
goto elna_declaration_module_declaration_procedure
|
||||
end
|
||||
end
|
||||
|
||||
proc elna_error_print_token1(kind: ElnaLexerKind)
|
||||
begin
|
||||
if kind = ElnaLexerKind.identifier then
|
||||
@@ -5575,8 +5672,6 @@ begin
|
||||
_write_s(stderr, "\"~\"")
|
||||
elsif kind = ElnaLexerKind._return then
|
||||
_write_s(stderr, "\"return\"")
|
||||
elsif kind = ElnaLexerKind._program then
|
||||
_write_s(stderr, "\"program\"")
|
||||
elsif kind = ElnaLexerKind._cast then
|
||||
_write_s(stderr, "\"cast\"")
|
||||
elsif kind = ElnaLexerKind.trait then
|
||||
@@ -5635,6 +5730,8 @@ begin
|
||||
_write_s(stderr, "CHARACTER")
|
||||
elsif kind = ElnaLexerKind.integer then
|
||||
_write_s(stderr, "INTEGER")
|
||||
elsif kind = ElnaLexerKind.word then
|
||||
_write_s(stderr, "WORD")
|
||||
else
|
||||
elna_error_print_token2(kind)
|
||||
end
|
||||
@@ -5642,9 +5739,7 @@ end
|
||||
|
||||
proc elna_error_print_token2(kind: ElnaLexerKind)
|
||||
begin
|
||||
if kind = ElnaLexerKind.word then
|
||||
_write_s(stderr, "WORD")
|
||||
elsif kind = ElnaLexerKind._goto then
|
||||
if kind = ElnaLexerKind._goto then
|
||||
_write_s(stderr, "\"goto\"")
|
||||
elsif kind = ElnaLexerKind.eof then
|
||||
_write_s(stderr, "EOF")
|
||||
@@ -5688,6 +5783,7 @@ begin
|
||||
compiled := elna_list_empty(@error_list);
|
||||
|
||||
if compiled then
|
||||
elna_declaration_module_declaration(parser_node);
|
||||
elna_name_module_declaration(parser_node);
|
||||
elna_type_module_declaration(parser_node);
|
||||
tac := elna_tac_module_declaration(parser_node);
|
||||
@@ -5713,9 +5809,9 @@ end
|
||||
*
|
||||
* Returns the symbol pointer or nil.
|
||||
*)
|
||||
proc elna_symbol_table_lookup(symbol_table: ^ElnaSymbolTable, symbol_name: Word, name_length: Word)
|
||||
proc elna_symbol_table_lookup(symbol_table: ^ElnaSymbolTable, symbol_name: ^Char, name_length: Word) -> Pointer
|
||||
var
|
||||
result: Word
|
||||
result: Pointer
|
||||
symbol_table_length: Word
|
||||
current_entry: ^ElnaSymbolEntry
|
||||
begin
|
||||
@@ -5832,39 +5928,39 @@ begin
|
||||
word_type^.kind := ElnaTypeKind.primitive;
|
||||
word_type^.size := 4;
|
||||
word_type^.alignment := 4;
|
||||
current_info := type_info_create(word_type);
|
||||
current_info := elna_symbol_type_info_create(word_type);
|
||||
elna_symbol_table_enter(symbol_table_global, "Word".ptr, 4, current_info);
|
||||
|
||||
int_type := malloc(#size(ElnaType));
|
||||
int_type^.kind := ElnaTypeKind.primitive;
|
||||
int_type^.size := 4;
|
||||
int_type^.alignment := 4;
|
||||
current_info := type_info_create(int_type);
|
||||
current_info := elna_symbol_type_info_create(int_type);
|
||||
elna_symbol_table_enter(symbol_table_global, "Int".ptr, 3, current_info);
|
||||
|
||||
current_type := malloc(#size(ElnaType));
|
||||
current_type^.kind := ElnaTypeKind.primitive;
|
||||
current_type^.size := 4;
|
||||
current_type^.alignment := 4;
|
||||
current_info := type_info_create(current_type);
|
||||
current_info := elna_symbol_type_info_create(current_type);
|
||||
elna_symbol_table_enter(symbol_table_global, "Pointer".ptr, 7, current_info);
|
||||
|
||||
bool_type := malloc(#size(ElnaType));
|
||||
bool_type^.kind := ElnaTypeKind.primitive;
|
||||
bool_type^.size := 1;
|
||||
bool_type^.alignment := 1;
|
||||
current_info := type_info_create(bool_type);
|
||||
current_info := elna_symbol_type_info_create(bool_type);
|
||||
elna_symbol_table_enter(symbol_table_global, "Bool".ptr, 4, current_info);
|
||||
|
||||
char_type := malloc(#size(ElnaType));
|
||||
char_type^.kind := ElnaTypeKind.primitive;
|
||||
char_type^.size := 1;
|
||||
char_type^.alignment := 1;
|
||||
current_info := type_info_create(char_type);
|
||||
current_info := elna_symbol_type_info_create(char_type);
|
||||
elna_symbol_table_enter(symbol_table_global, "Char".ptr, 4, current_info);
|
||||
|
||||
elna_symbol_string_build();
|
||||
current_info := type_info_create(string_type);
|
||||
current_info := elna_symbol_type_info_create(string_type);
|
||||
elna_symbol_table_enter(symbol_table_global, "String".ptr, 6, current_info)
|
||||
end
|
||||
|
||||
|
||||
Reference in New Issue
Block a user