Delcare extern procedures from libc

1 files changed, 257 insertions, 161 deletions

diff --git a/boot/stage23/cl.elna b/boot/stage23/cl.elna
index caebd84..2ea751b 100644
--- a/boot/stage23/cl.elna
+++ b/boot/stage23/cl.elna
@@ -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
+end
+
+proc elna_name_simple_expression(parser_node: ^ElnaTreeNode, symbol_table: ^ElnaSymbolTable)
 begin
-	(* Not interested in literals and variable expressions. *)
+	(* 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);
-
-	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);
+	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_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,22 +5552,81 @@ proc elna_type_module_declaration(parser_node: ^ElnaTreeModuleDeclaration)
 var
 	current_part: ^ElnaTreeDeclaration
 begin
+	current_part := parser_node^.procedures;
+	.elna_type_module_declaration_procedure;
+	if current_part <> nil then
+		elna_type_procedure_declaration(current_part);
+		current_part := current_part^.next;
+
+		goto elna_type_module_declaration_procedure
+	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_type_module_declaration_type;
+	.elna_declaration_module_declaration_type;
 	if current_part <> nil then
-		elna_type_type_declaration(current_part);
+		elna_declaration_type_declaration(current_part);
 		current_part := current_part^.next;
 
-		goto elna_type_module_declaration_type
+		goto elna_declaration_module_declaration_type
 	end;
 
 	current_part := parser_node^.procedures;
-	.elna_type_module_declaration_procedure;
+	.elna_declaration_module_declaration_procedure;
 	if current_part <> nil then
-		elna_type_procedure_declaration(current_part);
+		elna_declaration_procedure_declaration(current_part);
 		current_part := current_part^.next;
 
-		goto elna_type_module_declaration_procedure
+		goto elna_declaration_module_declaration_procedure
 	end
 end
 
@@ -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