Update the old compiler with the new syntax

11 files changed, 4570 insertions, 801 deletions

diff --git a/source/ast.elna b/source/ast.elna
new file mode 100644
index 0000000..ddae997
--- /dev/null
+++ b/source/ast.elna
@@ -0,0 +1,270 @@
+(* 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/. *)
+module
+import common, lexer
+
+type
+	ElnaListNode* = record
+		next: ^ElnaListNode
+	end
+	ElnaList* = record
+		first: ^ElnaListNode;
+		last: ^ElnaListNode
+	end
+
+	(* Type representation. *)
+	ElnaTypeKind* = (primitive, enumeration, _record, pointer, array, alias, procedure)
+	ElnaType* = record
+		kind: ElnaTypeKind;
+		size: Word;
+		alignment: Word
+	end
+	ElnaTypeAlias* = record(ElnaType)
+		base: ^ElnaType
+	end
+	ElnaTypeEnumeration* = record(ElnaType)
+		members: ^[]const Word8;
+		length: Word
+	end
+	ElnaTypeField* = record
+		name: []const Word8;
+		field_type: ^ElnaType
+	end
+	ElnaTypeRecord* = record(ElnaType)
+		members: ^ElnaTypeField;
+		length: Word
+	end
+	ElnaTypePointer* = record(ElnaType)
+		base: ^ElnaType
+	end
+	ElnaTypeArray* = record(ElnaType)
+		base: ^ElnaType;
+		length: Word
+	end
+	ElnaTypeProcedure* = record(ElnaType)
+		return_type: ^ElnaType
+	end
+
+	(* Abstract syntax tree nodes. *)
+	ElnaTreeKind* = (
+		integer_literal,
+		string_literal,
+		character_literal,
+		boolean_literal,
+		variable_expression,
+		field_access_expression,
+		dereference_expression,
+		unary_expression,
+		binary_expression,
+		call,
+		call_statement,
+		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,
+		array_access_expression,
+		_cast
+	)
+	ElnaTreeNode* = record
+		kind: ElnaTreeKind;
+		position: ElnaPosition
+	end
+	ElnaTreeTypeExpression* = record(ElnaTreeNode)
+	end
+	ElnaTreeExpression* = record(ElnaTreeNode)
+		type_decoration: ^ElnaType
+	end
+	ElnaTreeIntegerLiteral* = record(ElnaTreeExpression)
+		value: Word
+	end
+	ElnaTreeCharacterLiteral* = record(ElnaTreeExpression)
+		value: Word8
+	end
+	ElnaTreeNilLiteral* = record(ElnaTreeExpression)
+	end
+	ElnaTreeBooleanLiteral* = record(ElnaTreeExpression)
+		value: Bool
+	end
+	ElnaTreeStringLiteral* = record(ElnaTreeExpression)
+		value: []const Word8
+	end
+	ElnaTreeVariableExpression* = record(ElnaTreeExpression)
+		name: []const Word8
+	end
+	ElnaTreeCastExpression* = record(ElnaTreeExpression)
+		expression: ^ElnaTreeExpression;
+		type_expression: ^ElnaTreeTypeExpression
+	end
+	ElnaTreeDereferenceExpression* = record(ElnaTreeExpression)
+		pointer: ^ElnaTreeExpression
+	end
+	ElnaTreeBinaryExpression* = record(ElnaTreeExpression)
+		lhs: ^ElnaTreeExpression;
+		rhs: ^ElnaTreeExpression;
+		operator: ElnaLexerKind
+	end
+	ElnaTreeUnaryExpression* = record(ElnaTreeExpression)
+		operand: ^ElnaTreeExpression;
+		operator: ElnaLexerKind
+	end
+	ElnaTreeFieldAccessExpression* = record(ElnaTreeExpression)
+		aggregate: ^ElnaTreeExpression;
+		field: []const Word8
+	end
+	ElnaTreeArrayAccessExpression* = record(ElnaTreeExpression)
+		array: ^ElnaTreeExpression;
+		index: ^ElnaTreeExpression
+	end
+	ElnaTreeTraitExpression* = record(ElnaTreeExpression)
+		name: []const Word8;
+		argument: ^ElnaTreeTypeExpression
+	end
+	ElnaTreeExpressionList* = record
+		expression: ^ElnaTreeExpression;
+		next: ^ElnaTreeExpressionList
+	end
+	ElnaTreeCall* = record(ElnaTreeExpression)
+		callee: ^ElnaTreeVariableExpression;
+		arguments: ^ElnaTreeExpressionList;
+		count: Word
+	end
+
+	(* Statements. *)
+	ElnaTreeStatement* = record(ElnaTreeNode)
+		next: ^ElnaTreeStatement
+	end
+	ElnaTreeConditionalStatements* = record
+		condition: ^ElnaTreeExpression;
+		statements: ^ElnaTreeStatement;
+		next: ^ElnaTreeConditionalStatements
+	end
+	ElnaTreeIfStatement* = record(ElnaTreeStatement)
+		conditionals: ^ElnaTreeConditionalStatements;
+		_else: ^ElnaTreeStatement
+	end
+	ElnaTreeGotoStatement* = record(ElnaTreeStatement)
+		label: []const Word8
+	end
+	ElnaTreeAssignStatement* = record(ElnaTreeStatement)
+		assignee: ^ElnaTreeExpression;
+		assignment: ^ElnaTreeExpression
+	end
+	ElnaTreeReturnStatement* = record(ElnaTreeStatement)
+		returned: ^ElnaTreeExpression
+	end
+	ElnaTreeLabelDeclaration* = record(ElnaTreeStatement)
+		label: []const Word8
+	end
+	ElnaTreeCallStatement* = record(ElnaTreeStatement)
+		call: ^ElnaTreeCall
+	end
+
+	(* Type expressions. *)
+	ElnaTreeEnumeration* = record
+		name: []const Word8;
+		next: ^ElnaTreeEnumeration
+	end
+	ElnaTreeEnumerationTypeExpression* = record(ElnaTreeTypeExpression)
+		members: ^ElnaTreeEnumeration;
+		length: Word
+	end
+	ElnaTreeField* = record
+		name: []const Word8;
+		type_expression: ^ElnaTreeTypeExpression;
+		next: ^ElnaTreeField
+	end
+	ElnaTreeRecordTypeExpression* = record(ElnaTreeTypeExpression)
+		members: ^ElnaTreeField;
+		length: Word;
+		parent: []const Word8
+	end
+	ElnaTreeNamedTypeExpression* = record(ElnaTreeTypeExpression)
+		name: []const Word8
+	end
+	ElnaTreePointerTypeExpression* = record(ElnaTreeTypeExpression)
+		base: ^ElnaTreeTypeExpression
+	end
+	ElnaTreeArrayTypeExpression* = record(ElnaTreeTypeExpression)
+		base: ^ElnaTreeTypeExpression;
+		length: ^ElnaTreeExpression
+	end
+
+	(* Declarations. *)
+	ElnaTreeDeclaration* = record(ElnaTreeNode)
+		next: ^ElnaTreeDeclaration;
+		name: []const Word8
+	end
+	ElnaTreeVariableDeclaration* = record(ElnaTreeDeclaration)
+		type_expression: ^ElnaTreeTypeExpression
+	end
+	ElnaTreeProcedureDeclaration* = record(ElnaTreeDeclaration)
+		body: ^ElnaTreeStatement;
+		temporaries: ^ElnaTreeVariableDeclaration;
+		parameters: ^ElnaTreeVariableDeclaration;
+		return_type: ^ElnaTreeTypeExpression;
+		is_extern: Bool
+	end
+	ElnaTreeTypeDeclaration* = record(ElnaTreeDeclaration)
+		type_expression: ^ElnaTreeTypeExpression
+	end
+	ElnaTreeModuleDeclaration* = record(ElnaTreeNode)
+		types: ^ElnaTreeDeclaration;
+		globals: ^ElnaTreeVariableDeclaration;
+		procedures: ^ElnaTreeProcedureDeclaration;
+		body: ^ElnaTreeStatement
+	end
+
+proc elna_list_initialize*(list: ^ElnaList)
+begin
+	list^.first := nil;
+	list^.last := nil
+return
+
+proc elna_list_append*(list: ^ElnaList; element: ^ElnaListNode) -> ^ElnaListNode
+begin
+	if element <> nil then
+		if list^.first = nil then
+			list^.first := element
+		else
+			list^.last^.next := element
+		end;
+		list^.last := element
+	end
+return element
+
+proc elna_list_prepend*(list: ^ElnaList; element: ^ElnaListNode)
+begin
+	element^.next := list^.first;
+	list^.first := element;
+	if list^.last = nil then
+		list^.last := element
+	end
+return
+
+proc elna_list_insert*(list: ^ElnaList; existing, new: ^ElnaListNode)
+begin
+	if existing^.next = nil then
+		list^.last := new
+	else
+		new^.next := existing^.next
+	end;
+	existing^.next := new
+return
+
+proc elna_list_empty*(list: ^ElnaList) -> Bool
+return list^.first = nil
+
+end.
diff --git a/source/common.elna b/source/common.elna
index 428c4ec..65b0a65 100644
--- a/source/common.elna
+++ b/source/common.elna
@@ -78,4 +78,12 @@ begin
 	end
 return result
 
+proc free_and_nil*#[T](ptr: ^T) -> ^T
+begin
+	if ptr <> nil then
+		free(ptr)
+	end
+return nil
+
 end.
+
diff --git a/source/diagnostic.elna b/source/diagnostic.elna
new file mode 100644
index 0000000..771ce38
--- /dev/null
+++ b/source/diagnostic.elna
@@ -0,0 +1,241 @@
+(* 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/. *)
+module
+import common, cstdio, cstdlib, lexer, ast
+
+type
+	ElnaErrorKind* = (
+		unexpected_token,
+		undefined_symbol,
+		undefined_member,
+		duplicate_declaration
+	)
+	ElnaError* = record(ElnaListNode)
+		kind: ElnaErrorKind;
+		position: ElnaPosition
+	end
+	ElnaErrorUnexpectedToken* = record(ElnaError)
+		expected: [16]ElnaLexerKind;
+		possibilities: Word;
+		got: ElnaLexerKind
+	end
+	ElnaErrorUndefinedSymbol* = record(ElnaError)
+		symbol_name: []const Word8
+	end
+	ElnaErrorUndefinedMember* = record(ElnaError)
+		aggregate_name: []const Word8;
+		member_name: []const Word8
+	end
+	ElnaErrorDuplicateDeclaration* = record(ElnaError)
+		symbol_name: []const Word8
+	end
+
+proc elna_error_unexpected_token_create*(cursor: ^ElnaLexerCursor; number_of_expected: Word) -> ^ElnaErrorUnexpectedToken
+var
+	parser_error: ^ElnaErrorUnexpectedToken
+begin
+	parser_error := malloc#[ElnaErrorUnexpectedToken](#size(ElnaErrorUnexpectedToken));
+	parser_error^.next := nil;
+	parser_error^.kind := ElnaErrorKind.unexpected_token;
+	parser_error^.position := cursor^.position;
+	parser_error^.possibilities := number_of_expected;
+	parser_error^.got := cursor^.token^.kind
+return parser_error
+
+proc elna_error_duplicate_declaration_create*(position: ElnaPosition; symbol_name: []const Word8) -> ^ElnaErrorDuplicateDeclaration
+var
+	declaration_error: ^ElnaErrorDuplicateDeclaration
+begin
+	declaration_error := malloc#[ElnaErrorDuplicateDeclaration](#size(ElnaErrorDuplicateDeclaration));
+	declaration_error^.next := nil;
+	declaration_error^.kind := ElnaErrorKind.duplicate_declaration;
+	declaration_error^.position := position;
+	declaration_error^.symbol_name := symbol_name
+return declaration_error
+
+proc elna_error_undefined_symbol_create*(position: ElnaPosition; symbol_name: []const Word8) -> ^ElnaErrorUndefinedSymbol
+var
+	result: ^ElnaErrorUndefinedSymbol
+begin
+	result := malloc#[ElnaErrorUndefinedSymbol](#size(ElnaErrorUndefinedSymbol));
+	result^.next := nil;
+	result^.kind := ElnaErrorKind.undefined_symbol;
+	result^.position := position;
+	result^.symbol_name := symbol_name
+return result
+
+proc elna_error_undefined_member_create*(position: ElnaPosition; aggregate, member: []const Word8) -> ^ElnaErrorUndefinedMember
+var
+	result: ^ElnaErrorUndefinedMember
+begin
+	result := malloc#[ElnaErrorUndefinedMember](#size(ElnaErrorUndefinedMember));
+	result^.next := nil;
+	result^.kind := ElnaErrorKind.undefined_member;
+	result^.position := position;
+	result^.aggregate_name := aggregate;
+	result^.member_name := member
+return result
+
+proc elna_error_print_token*(kind: ElnaLexerKind)
+begin
+	case kind of
+		ElnaLexerKind._const:
+			write_s("\"const\"")
+		| ElnaLexerKind._var:
+			write_s("\"var\"")
+		| ElnaLexerKind._proc:
+			write_s("\"proc\"")
+		| ElnaLexerKind._type:
+			write_s("\"type\"")
+		| ElnaLexerKind._begin:
+			write_s("\"begin\"")
+		| ElnaLexerKind._end:
+			write_s("\"end\"")
+		| ElnaLexerKind._if:
+			write_s("\"if\"")
+		| ElnaLexerKind._then:
+			write_s("\"then\"")
+		| ElnaLexerKind._else:
+			write_s("\"else\"")
+		| ElnaLexerKind._elsif:
+			write_s("\"elsif\"")
+		| ElnaLexerKind._extern:
+			write_s("\"extern\"")
+		| ElnaLexerKind._record:
+			write_s("\"record\"")
+		| ElnaLexerKind.boolean:
+			write_s("BOOLEAN")
+		| ElnaLexerKind.null:
+			write_s("NIL")
+		| ElnaLexerKind.and:
+			write_s("\"&\"")
+		| ElnaLexerKind._or:
+			write_s("\"or\"")
+		| ElnaLexerKind._xor:
+			write_s("\"xor\"")
+		| ElnaLexerKind.not:
+			write_s("\"~\"")
+		| ElnaLexerKind._return:
+			write_s("\"return\"")
+		| ElnaLexerKind._cast:
+			write_s("\"cast\"")
+		| ElnaLexerKind.trait:
+			write_s("TRAIT")
+		| ElnaLexerKind.left_paren:
+			write_s("\"(\"")
+		| ElnaLexerKind.right_paren:
+			write_s("\")\"")
+		| ElnaLexerKind.left_square:
+			write_s("\"[\"")
+		| ElnaLexerKind.right_square:
+			write_s("\"]\"")
+		| ElnaLexerKind.greater_equal:
+			write_s("\">=\"")
+		| ElnaLexerKind.less_equal:
+			write_s("\"<=\"")
+		| ElnaLexerKind.greater_than:
+			write_s("\">\"")
+		| ElnaLexerKind.less_than:
+			write_s("\"<\"")
+		| ElnaLexerKind.not_equal:
+			write_s("\"<>\"")
+		| ElnaLexerKind.equals:
+			write_s("\"=\"")
+		| ElnaLexerKind.semicolon:
+			write_s("\";\"")
+		| ElnaLexerKind.dot:
+			write_s("\".\"")
+		| ElnaLexerKind.comma:
+			write_s("\",\"")
+		| ElnaLexerKind.plus:
+			write_s("\"+\"")
+		| ElnaLexerKind.arrow:
+			write_s("\"->\"")
+		| ElnaLexerKind.minus:
+			write_s("\"-\"")
+		| ElnaLexerKind.multiplication:
+			write_s("\"*\"")
+		| ElnaLexerKind.division:
+			write_s("\"/\"")
+		| ElnaLexerKind.remainder:
+			write_s("\"%\"")
+		| ElnaLexerKind.assignment:
+			write_s("\":=\"")
+		| ElnaLexerKind.colon:
+			write_s("\":\"")
+		| ElnaLexerKind.hat:
+			write_s("\"^\"")
+		| ElnaLexerKind.at:
+			write_s("\"@\"")
+		| ElnaLexerKind.comment:
+			write_s("COMMENT")
+		| ElnaLexerKind.string:
+			write_s("STRING")
+		| ElnaLexerKind.character:
+			write_s("CHARACTER")
+		| ElnaLexerKind.integer:
+			write_s("INTEGER")
+		| ElnaLexerKind.word:
+			write_s("WORD")
+		| ElnaLexerKind.eof:
+			write_s("EOF")
+		else
+			write_s("UNKNOWN")
+	end
+return
+
+proc elna_error_print_unexpected_token*(current_error: ^ElnaErrorUnexpectedToken)
+begin
+	write_s("Parse error: Expecting token ");
+	elna_error_print_token(current_error^.expected[1]);
+	write_s("; got ");
+	elna_error_print_token(current_error^.got);
+	write_s(". ")
+return
+
+proc elna_error_print_undefined_member*(current_error: ^ElnaErrorUndefinedMember)
+begin
+	write_s("Semantic error: Member \"");
+	write_s(current_error^.member_name);
+	write_s("\" is not accessible on \"");
+	write_s(current_error^.aggregate_name);
+	write_s("\". ")
+return
+
+proc elna_error_print_undefined_symbol*(current_error: ^ElnaErrorUndefinedSymbol)
+begin
+	write_s("Semantic error: Undefined symbol \"");
+	write_s(current_error^.symbol_name);
+	write_s("\". ")
+return
+
+proc elna_error_print_duplicate_declaration*(current_error: ^ElnaErrorDuplicateDeclaration)
+begin
+	write_s("Semantic error: Duplicate declaration \"");
+	write_s(current_error^.symbol_name);
+	write_s("\". ")
+return
+
+proc elna_error_print*(current_error: ^ElnaError)
+begin
+	case current_error^.kind of
+		ElnaErrorKind.unexpected_token:
+			elna_error_print_unexpected_token(cast(current_error: ^ElnaErrorUnexpectedToken))
+		| ElnaErrorKind.undefined_symbol:
+			elna_error_print_undefined_symbol(cast(current_error: ^ElnaErrorUndefinedSymbol))
+		| ElnaErrorKind.undefined_member:
+			elna_error_print_undefined_member(cast(current_error: ^ElnaErrorUndefinedMember))
+		| ElnaErrorKind.duplicate_declaration:
+			elna_error_print_duplicate_declaration(cast(current_error: ^ElnaErrorDuplicateDeclaration))
+		else
+			write_s("Unknown error. ")
+	end;
+	write_s("Line ");
+	write_u(current_error^.position.start_location.line);
+	write_s(", column ");
+	write_u(current_error^.position.start_location.column);
+	write_s(".\n")
+return
+
+end.
diff --git a/source/lexer.elna b/source/lexer.elna
index 370c24d..9ba593f 100644
--- a/source/lexer.elna
+++ b/source/lexer.elna
@@ -5,7 +5,7 @@ module
 import cstdio, common, cstdlib
 
 type
-  ElnaLexerState = (
+  ElnaLexerState* = (
     start,
     colon,
     identifier,
@@ -28,7 +28,7 @@ type
   )
   ElnaLexerToken* = record
     kind: ElnaLexerKind;
-    start: []const Word8; (* DEPRECATED *)
+    start: []const Word8;
     position: ElnaPosition
   end
   ElnaLexerBooleanToken* = record(ElnaLexerToken)
@@ -45,7 +45,6 @@ type
   end
 
   TransitionAction = proc(lexer: ^Lexer; token: ^ElnaLexerToken)
-  (* DEPRECATED should be replaced with TransitionAction (but keeping the type name). *)
   ElnaLexerAction = (none, accumulate, skip, single, eof, finalize, composite, key_id, integer, delimited)
 
   ElnaLexerTransition = record
@@ -53,7 +52,7 @@ type
     next_state: ElnaLexerState
   end
 
-  ElnaLexerCursor = record
+  ElnaLexerCursor* = record
     state: ElnaLexerState;
     start: ^Word8;
     finish: ^Word8;
@@ -755,7 +754,7 @@ return elna_lexer_execute_action(cursor, next_transition^.action)
 (**
  * One time lexer initialization.
  *)
-proc elna_lexer_initialize(cursor: ^ElnaLexerCursor; code_pointer: ^Word8)
+proc elna_lexer_initialize*(cursor: ^ElnaLexerCursor; code_pointer: ^Word8)
 begin
 	elna_lexer_classifications();
 	elna_lexer_transitions();
@@ -771,7 +770,7 @@ return
  * Reads the next token and writes its type into the address in the kind parameter.
  * Resets the lexer state for reading the next token.
  *)
-proc elna_lexer_peek(cursor: ^ElnaLexerCursor) -> ^ElnaLexerToken
+proc elna_lexer_peek*(cursor: ^ElnaLexerCursor) -> ^ElnaLexerToken
 var
 	token: ^ElnaLexerToken
 begin
@@ -788,7 +787,7 @@ return cursor^.token
 (**
  * Reads the token and advance the lexer.
  *)
-proc elna_lexer_read(cursor: ^ElnaLexerCursor) -> ^ElnaLexerToken
+proc elna_lexer_read*(cursor: ^ElnaLexerCursor) -> ^ElnaLexerToken
 var
 	token: ^ElnaLexerToken
 begin
@@ -801,7 +800,7 @@ return token
 (**
  * Skips comments.
  *)
-proc elna_lexer_skip_empty_lines(cursor: ^ElnaLexerCursor)
+proc elna_lexer_skip_empty_lines*(cursor: ^ElnaLexerCursor)
 var
 	token: ^ElnaLexerToken
 begin
diff --git a/source/main.elna b/source/main.elna
index 26853c3..6049362 100644
--- a/source/main.elna
+++ b/source/main.elna
@@ -4,813 +4,139 @@
 
 program(parameters)
 import
-  cstdio, cstdlib, cstring, cctype, common, command_line_interface, lexer
-
-type
-  SourceFile* = record
-    buffer: [1024]Word8;
-    handle: ^FILE;
-    size: Word;
-    index: Word
-  end
-  StringBuffer* = record
-    data: ^Word8;
-    size: Word;
-    capacity: Word
-  end
-  SourceCode#[T] = record
-    position: ElnaLocation;
-
-    input: ^T;
-    empty: proc(stream: ^T) -> Bool;
-    advance: proc(stream: ^T);
-    head: proc(stream: ^T) -> Word8
-  end
-  Tokenizer* = record
-    length: Word;
-    data: ^^ElnaLexerToken
-  end
-
-(*
-  Standard procedures.
-*)
-proc string_dup(origin: []const Word8) -> []const Word8
-var
-  copy: ^Word8
-begin
-  copy := malloc#[Word8](origin.length);
-  strncpy(copy, origin.ptr, origin.length)
-return copy[1 to origin.length]
-
-proc string_buffer_new() -> StringBuffer
-var
-  result: StringBuffer
-begin
-  result.capacity := 64u;
-  result.data := malloc#[Word8](result.capacity);
-  result.size := 0u
-return result
-
-proc string_buffer_push(buffer: ^StringBuffer; char: Word8)
-begin
-  if buffer^.size >= buffer^.capacity then
-    buffer^.capacity := buffer^.capacity + 1024u;
-    buffer^.data := realloc(buffer^.data, buffer^.capacity)
-  end;
-  cast(buffer^.data + buffer^.size: ^Word8)^ := cast(char: Word8);
-  buffer^.size := buffer^.size + 1u
-return
-
-proc string_buffer_pop(buffer: ^StringBuffer; count: Word)
-begin
-  buffer^.size := buffer^.size - count
-return
-
-proc string_buffer_clear(buffer: ^StringBuffer) -> []const Word8
-var
-  result: []const Word8
-begin
-  result := cast(buffer^.data: ^Word8)[1 to buffer^.size];
-  buffer^.size := 0u
+  cstdio, cstdlib, cstring, common, command_line_interface,
+  lexer, ast, diagnostic, symbol, parser, name_analysis, type_check, tac, qbe
+
+proc read_file_to_buffer(filename: ^Word8) -> []const Word8
+var
+	file_handle: ^FILE
+	file_size: Int
+	buffer: ^Word8
+	bytes_read: Word
+	result: []const Word8
+begin
+	file_handle := fopen(filename, "rb\0".ptr);
+	if file_handle = nil then
+		perror(filename);
+		exit(3)
+	end;
+	fseek(file_handle, 0, 2);
+	file_size := ftell(file_handle);
+	rewind(file_handle);
+
+	buffer := malloc#[Word8](cast(file_size: Word) + 1u);
+	bytes_read := fread#[Word8](buffer, 1u, cast(file_size: Word), file_handle);
+	(buffer + bytes_read)^ := cast(0: Word8);
+	fclose(file_handle);
+
+	result := buffer[1u to bytes_read]
 return result
 
-(*
-  Source code stream procedures.
-*)
-
-proc read_source(filename: ^Word8) -> ^SourceFile
-var
-  result: ^SourceFile
-  file_handle: ^FILE
-begin
-  file_handle := fopen(filename, "rb\0".ptr);
-
-  if file_handle <> nil then
-    result := malloc#[SourceFile](#size(SourceFile));
-    result^.handle := file_handle;
-    result^.size := 0u;
-    result^.index := 1u
-  end
-return result
-
-proc source_file_empty(source_input: ^SourceFile) -> Bool
-  if source_input^.index > source_input^.size then
-    source_input^.size := fread(source_input^.buffer.ptr, 1u, 1024u, source_input^.handle);
-    source_input^.index := 1u
-  end
-return source_input^.size = 0u
-
-proc source_file_head(source_input: ^SourceFile) -> Word8
-return source_input^.buffer[source_input^.index]
-
-proc source_file_advance(source_input: ^SourceFile)
-  source_input^.index := source_input^.index + 1u
-return
-
-proc source_code_empty#[T](source_code: ^SourceCode#[T]) -> Bool
-return source_code^.empty(source_code^.input)
-
-proc source_code_head#[T](source_code: SourceCode#[T]) -> Word8
-return source_code.head(source_code.input)
-
-proc source_code_advance#[T](source_code: ^SourceCode#[T])
-begin
-  source_code^.advance(source_code^.input);
-  source_code^.position.column := source_code^.position.column
-return
-
-proc source_code_break#[T](source_code: ^SourceCode#[T])
-begin
-  source_code^.position.line := source_code^.position.line + 1u;
-  source_code^.position.column := 0u
-return
-
-proc source_code_expect#[T](source_code: ^SourceCode#[T]; expected: Word8) -> Bool
-return ~source_code_empty(source_code) & source_code_head(source_code^) = expected
-
-(*
-  Token procedures.
-*)
-
-proc lexer_escape(escape: Word8; result: ^Word8) -> Bool
-var
-  successful: Bool
-begin
-  case escape of
-    'n':
-      result^ := '\n';
-      successful := true
-    | 't':
-      result^ := '\t';
-      successful := true
-    | 'f':
-      result^ := '\f';
-      successful := true
-    | 'r':
-      result^ := '\r';
-      successful := true
-    | 'v':
-      result^ := '\v';
-      successful := true
-    | '\\':
-      result^ := '\\';
-      successful := true
-    | '\'':
-      result^ := '\'';
-      successful := true
-    | '"':
-      result^ := '"';
-      successful := true
-    | '0':
-      result^ := '\0';
-      successful := true
-    else
-      successful := false
-  end
-return successful
-
-(* Skip spaces. *)
-proc lexer_spaces#[T](source_code: ^SourceCode#[T])
-var
-  current: Word8
-begin
-  while ~source_code_empty(source_code) & isspace(cast(source_code_head(source_code^): Int)) <> 0 do
-    current := source_code_head(source_code^);
-
-    if current = '\n' then
-      source_code_break(source_code)
-    end;
-    source_code_advance(source_code)
-  end
-return
-
-(* Checker whether the character is allowed in an identificator. *)
-proc lexer_is_ident(char: Word8) -> Bool
-return isalnum(cast(char: Int)) <> 0 or char = '_'
-
-proc lexer_identifier#[T](source_code: ^SourceCode#[T]; token_content: ^StringBuffer)
-var
-  content_length: Word
-begin
-  while ~source_code_empty(source_code) & lexer_is_ident(source_code_head(source_code^)) do
-    string_buffer_push(token_content, source_code_head(source_code^));
-    source_code_advance(source_code)
-  end
-return
-
-proc lexer_comment#[T](source_code: ^SourceCode#[T]; token_content: ^StringBuffer) -> Bool
-var
-  trailing: Word
-begin
-  trailing := 0u;
-
-  while ~source_code_empty(source_code) & trailing < 2u do
-    if source_code_head(source_code^) = '*' then
-      string_buffer_push(token_content, '*');
-      trailing := 1u
-    elsif source_code_head(source_code^) = ')' & trailing = 1u then
-      string_buffer_pop(token_content, 1u);
-      trailing := 2u
-    else
-      string_buffer_push(token_content, source_code_head(source_code^));
-      trailing := 0u
-    end;
-    source_code_advance(source_code)
-  end
-return trailing = 2u
-
-proc lexer_character#[T](source_code: ^SourceCode#[T]; token_content: ^Word8) -> Bool
-var
-  successful: Bool
-begin
-  successful := ~source_code_empty(source_code);
-
-  if successful then
-    if source_code_head(source_code^) = '\\' then
-      source_code_advance(source_code);
-
-      successful := ~source_code_empty(source_code) & lexer_escape(source_code_head(source_code^), token_content)
-    else
-      token_content^ := source_code_head(source_code^);
-      successful := true
-    end
-  end;
-  if successful then
-    source_code_advance(source_code)
-  end
-return successful
-
-proc lexer_string#[T](source_code: ^SourceCode#[T]; token_content: ^StringBuffer) -> Bool
+proc print_errors(error_list: ^ElnaList)
 var
-  token_end, constructed_string: ^Word8
-  token_length: Word
-  is_valid: Bool := true
-  next_char: Word8
-begin
-  while is_valid & ~source_code_empty(source_code) & source_code_head(source_code^) <> '"' do
-    is_valid := lexer_character(source_code, @next_char);
-
-    if is_valid then
-      string_buffer_push(token_content, next_char)
-    end
-  end;
-
-  if is_valid & source_code_expect(source_code, '"') then
-    source_code_advance(source_code)
-  else
-    is_valid := false
-  end
-return is_valid
-
-proc lexer_number#[T](source_code: ^SourceCode#[T]; token_content: ^Int)
+	node: ^ElnaListNode
 begin
-  token_content^ := 0;
-
-  while ~source_code_empty(source_code) & isdigit(cast(source_code_head(source_code^): Int)) <> 0 do
-    token_content^ := token_content^ * 10 + (cast(source_code_head(source_code^): Int) - cast('0': Int));
-
-    source_code_advance(source_code)
-  end
+	node := error_list^.first;
+	while node <> nil do
+		elna_error_print(cast(node: ^ElnaError));
+		node := node^.next
+	end
 return
 
-(* Categorize an identifier. *)
-proc lexer_categorize(token_content: []const Word8) -> ^ElnaLexerToken
-var
-  current_token: ^ElnaLexerToken
-begin
-  if token_content = "if" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._if
-  elsif token_content = "then" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._then
-  elsif token_content = "else" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._else
-  elsif token_content = "elsif" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._elsif
-  elsif token_content = "while" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._while
-  elsif token_content = "do" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._do
-  elsif token_content = "proc" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._proc
-  elsif token_content = "begin" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._begin
-  elsif token_content = "end" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._end
-  elsif token_content = "extern" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._extern
-  elsif token_content = "const" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._const
-  elsif token_content = "var" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._var
-  elsif token_content = "case" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._case
-  elsif token_content = "of" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._of
-  elsif token_content = "type" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._type
-  elsif token_content = "record" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._record
-  elsif token_content = "true" then
-    current_token := malloc#[ElnaLexerBooleanToken](#size(ElnaLexerBooleanToken));
-    current_token^.kind := ElnaLexerKind.boolean;
-    cast(current_token: ^ElnaLexerBooleanToken)^.value := true
-  elsif token_content = "false" then
-    current_token := malloc#[ElnaLexerBooleanToken](#size(ElnaLexerBooleanToken));
-    current_token^.kind := ElnaLexerKind.boolean;
-    cast(current_token: ^ElnaLexerBooleanToken)^.value := false
-  elsif token_content = "nil" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.null
-  elsif token_content = "or" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._or
-  elsif token_content = "return" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._return
-  elsif token_content = "cast" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._cast
-  elsif token_content = "defer" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._defer
-  elsif token_content = "import" then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind._import
-  else
-    current_token := malloc#[ElnaLexerStringToken](#size(ElnaLexerStringToken));
-    current_token^.kind := ElnaLexerKind.identifier;
-    cast(current_token: ^ElnaLexerStringToken)^.value := string_dup(token_content)
-  end
-return current_token
-
-proc lexer_add_token(lexer: ^Tokenizer; token: ^ElnaLexerToken)
-var
-  new_length: Word
-begin
-  new_length := lexer^.length + 1u;
-  lexer^.data := realloc#[^ElnaLexerToken](lexer^.data, new_length * #size(^ElnaLexerToken));
-  (lexer^.data + lexer^.length)^ := token;
-  lexer^.length := new_length
-return
-
-(* Read the next token from the input. *)
-proc lexer_next#[T](source_code: SourceCode#[T]; token_buffer: ^StringBuffer) -> ^ElnaLexerToken
-var
-  current_token: ^ElnaLexerToken := nil
-  first_char: Word8
-begin
-  first_char := source_code_head(source_code);
-
-  if isalpha(cast(first_char: Int)) <> 0 or first_char = '_' then
-    lexer_identifier(@source_code, token_buffer);
-    current_token := lexer_categorize(string_buffer_clear(token_buffer))
-  elsif first_char = '#' then
-    source_code_advance(@source_code);
-    lexer_identifier(@source_code, token_buffer);
-
-    current_token := malloc#[ElnaLexerStringToken](#size(ElnaLexerStringToken));
-    current_token^.kind := ElnaLexerKind.trait;
-    cast(current_token: ^ElnaLexerStringToken)^.value := string_dup(string_buffer_clear(token_buffer))
-  elsif isdigit(cast(first_char: Int)) <> 0 then
-    current_token := malloc#[ElnaLexerIntegerToken](#size(ElnaLexerIntegerToken));
-    lexer_number(@source_code, @cast(current_token: ^ElnaLexerIntegerToken)^.value);
-
-    if source_code_expect(@source_code, 'u') then
-      current_token^.kind := ElnaLexerKind.word;
-      source_code_advance(@source_code)
-    else
-      current_token^.kind := ElnaLexerKind.integer
-    end
-  elsif first_char = '(' then
-    source_code_advance(@source_code);
-
-    if source_code_empty(@source_code) then
-      current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-      current_token^.kind := ElnaLexerKind.left_paren
-    elsif source_code_head(source_code) = '*' then
-      source_code_advance(@source_code);
-
-      if lexer_comment(@source_code, token_buffer) then
-        current_token := malloc#[ElnaLexerStringToken](#size(ElnaLexerStringToken));
-        cast(current_token: ^ElnaLexerStringToken)^.value := string_dup(string_buffer_clear(token_buffer));
-        current_token^.kind := ElnaLexerKind.comment
-      end
-    else
-      current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-      current_token^.kind := ElnaLexerKind.left_paren
-    end
-  elsif first_char = ')' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.right_paren;
-    source_code_advance(@source_code)
-  elsif first_char = '{' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.left_brace;
-    source_code_advance(@source_code)
-  elsif first_char = '}' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.right_brace;
-    source_code_advance(@source_code)
-  elsif first_char = '\'' then
-    source_code_advance(@source_code);
-
-    if lexer_character(@source_code, @first_char) & source_code_expect(@source_code, '\'') then
-      current_token := malloc#[ElnaLexerCharacterToken](#size(ElnaLexerCharacterToken));
-      current_token^.kind := ElnaLexerKind.character;
-      cast(current_token: ^ElnaLexerCharacterToken)^.value := first_char;
-      source_code_advance(@source_code)
-    end
-  elsif first_char = '"' then
-    source_code_advance(@source_code);
-
-    if lexer_string(@source_code, token_buffer) then
-      current_token := malloc#[ElnaLexerStringToken](#size(ElnaLexerStringToken));
-      current_token^.kind := ElnaLexerKind.string;
-      cast(current_token: ^ElnaLexerStringToken)^.value := string_dup(string_buffer_clear(token_buffer))
-    end
-  elsif first_char = '[' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.left_square;
-    source_code_advance(@source_code)
-  elsif first_char = ']' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.right_square;
-    source_code_advance(@source_code)
-  elsif first_char = '>' then
-    source_code_advance(@source_code);
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-
-    if source_code_empty(@source_code) then
-      current_token^.kind := ElnaLexerKind.greater_than
-    elsif source_code_head(source_code) = '=' then
-      current_token^.kind := ElnaLexerKind.greater_equal;
-      source_code_advance(@source_code)
-    elsif source_code_head(source_code) = '>' then
-      current_token^.kind := ElnaLexerKind.shift_right;
-      source_code_advance(@source_code)
-    else
-      current_token^.kind := ElnaLexerKind.greater_than
-    end
-  elsif first_char = '<' then
-    source_code_advance(@source_code);
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-
-    if source_code_empty(@source_code) then
-      current_token^.kind := ElnaLexerKind.less_than
-    elsif source_code_head(source_code) = '=' then
-      current_token^.kind := ElnaLexerKind.less_equal;
-      source_code_advance(@source_code)
-    elsif source_code_head(source_code) = '<' then
-      current_token^.kind := ElnaLexerKind.shift_left;
-      source_code_advance(@source_code)
-    elsif source_code_head(source_code) = '>' then
-      current_token^.kind := ElnaLexerKind.not_equal;
-      source_code_advance(@source_code)
-    else
-      current_token^.kind := ElnaLexerKind.less_than
-    end
-  elsif first_char = '=' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.equals;
-    source_code_advance(@source_code)
-  elsif first_char = ';' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.semicolon;
-    source_code_advance(@source_code)
-  elsif first_char = '.' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.dot;
-    source_code_advance(@source_code)
-  elsif first_char = ',' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.comma;
-    source_code_advance(@source_code)
-  elsif first_char = '+' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.plus;
-    source_code_advance(@source_code)
-  elsif first_char = '-' then
-    source_code_advance(@source_code);
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-
-    if source_code_empty(@source_code) then
-      current_token^.kind := ElnaLexerKind.minus
-    elsif source_code_head(source_code) = '>' then
-      current_token^.kind := ElnaLexerKind.arrow;
-      source_code_advance(@source_code)
-    else
-      current_token^.kind := ElnaLexerKind.minus
-    end
-  elsif first_char = '*' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.multiplication;
-    source_code_advance(@source_code)
-  elsif first_char = '/' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.division;
-    source_code_advance(@source_code)
-  elsif first_char = '%' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.remainder;
-    source_code_advance(@source_code)
-  elsif first_char = ':' then
-    source_code_advance(@source_code);
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-
-    if source_code_empty(@source_code) then
-      current_token^.kind := ElnaLexerKind.colon
-    elsif source_code_head(source_code) = '=' then
-      current_token^.kind := ElnaLexerKind.assignment;
-      source_code_advance(@source_code)
-    else
-      current_token^.kind := ElnaLexerKind.colon
-    end
-  elsif first_char = '^' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.hat;
-    source_code_advance(@source_code)
-  elsif first_char = '@' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.at;
-    source_code_advance(@source_code)
-  elsif first_char = '!' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.exclamation;
-    source_code_advance(@source_code)
-  elsif first_char = '&' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.and;
-    source_code_advance(@source_code)
-  elsif first_char = '~' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.not;
-    source_code_advance(@source_code)
-  elsif first_char = '|' then
-    current_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
-    current_token^.kind := ElnaLexerKind.pipe;
-    source_code_advance(@source_code)
-  end
-return current_token
-
-(* Split the source text into tokens. *)
-proc lexer_text#[T](source_code: SourceCode#[T]) -> Tokenizer
-var
-  current_token: ^ElnaLexerToken
-  token_buffer: StringBuffer
-  lexer: Tokenizer
-begin
-  lexer := Tokenizer{ length: 0u, data: nil };
-  token_buffer := string_buffer_new();
-
-  lexer_spaces(@source_code);
-
-  while ~source_code_empty(@source_code) do
-    current_token := lexer_next(source_code, @token_buffer);
-
-    if current_token <> nil then
-      lexer_add_token(@lexer, current_token);
-        lexer_spaces(@source_code)
-    else
-      write_s("Lexical analysis error on \"");
-      write_c(source_code_head(source_code));
-      write_s("\".\n")
-    end
-  end
-return lexer
-
-(*
-  Parser.
-*)
-
-proc parse(tokens: ^^ElnaLexerToken; tokens_size: Word)
-var
-  current_token: ^ElnaLexerToken
-  i: Word := 0u
-begin
-  while i < tokens_size do
-    current_token := (tokens + i)^;
-
-    case current_token^.kind of
-      ElnaLexerKind._if:
-        write_s("IF")
-      | ElnaLexerKind._then:
-        write_s("THEN")
-      | ElnaLexerKind._else:
-        write_s("ELSE")
-      | ElnaLexerKind._elsif:
-        write_s("ELSIF")
-      | ElnaLexerKind._while:
-        write_s("WHILE")
-      | ElnaLexerKind._do:
-        write_s("DO")
-      | ElnaLexerKind._proc:
-        write_s("PROC")
-      | ElnaLexerKind._begin:
-        write_s("BEGIN")
-      | ElnaLexerKind._end:
-        write_s("END")
-      | ElnaLexerKind._extern:
-        write_s("EXTERN")
-      | ElnaLexerKind._const:
-        write_s("CONST")
-      | ElnaLexerKind._var:
-        write_s("VAR")
-     | ElnaLexerKind._case:
-        write_s("CASE")
-      | ElnaLexerKind._of:
-        write_s("OF")
-      | ElnaLexerKind._type:
-        write_s("TYPE")
-      | ElnaLexerKind._record:
-        write_s("RECORD")
-      | ElnaLexerKind.pipe:
-        write_s("|")
-      | ElnaLexerKind.boolean:
-        write_s("BOOLEAN<");
-        write_b(cast(current_token: ^ElnaLexerBooleanToken)^.value);
-        write_c('>')
-      | ElnaLexerKind.null:
-        write_s("NIL")
-      | ElnaLexerKind.and:
-        write_s("&")
-      | ElnaLexerKind._or:
-        write_s("OR")
-      | ElnaLexerKind.not:
-        write_s("~")
-      | ElnaLexerKind._return:
-        write_s("RETURN")
-      | ElnaLexerKind._cast:
-        write_s("CAST")
-      | ElnaLexerKind.shift_left:
-        write_s("<<")
-      | ElnaLexerKind.shift_right:
-        write_s(">>")
-      | ElnaLexerKind.identifier:
-        write_c('<');
-        write_s(cast(current_token: ^ElnaLexerStringToken)^.value);
-        write_c('>')
-      | ElnaLexerKind.trait:
-        write_c('#');
-        write_s(cast(current_token: ^ElnaLexerStringToken)^.value)
-      | ElnaLexerKind.left_paren:
-        write_s("(")
-      | ElnaLexerKind.right_paren:
-        write_s(")")
-      | ElnaLexerKind.left_square:
-        write_s("[")
-      | ElnaLexerKind.right_square:
-        write_s("]")
-      | ElnaLexerKind.greater_equal:
-        write_s(">=")
-      | ElnaLexerKind.less_equal:
-        write_s("<=")
-      | ElnaLexerKind.greater_than:
-        write_s(">")
-      | ElnaLexerKind.less_than:
-        write_s("<")
-      | ElnaLexerKind.equals:
-        write_s("=")
-      | ElnaLexerKind.not_equal:
-        write_s("<>")
-      | ElnaLexerKind.semicolon:
-        write_c(';')
-      | ElnaLexerKind.dot:
-        write_c('.')
-      | ElnaLexerKind.comma:
-        write_c(',')
-      | ElnaLexerKind.plus:
-        write_c('+')
-      | ElnaLexerKind.minus:
-        write_c('-')
-      | ElnaLexerKind.multiplication:
-        write_c('*')
-      | ElnaLexerKind.division:
-        write_c('/')
-      | ElnaLexerKind.remainder:
-        write_c('%')
-      | ElnaLexerKind.assignment:
-        write_s(":=")
-      | ElnaLexerKind.colon:
-        write_c(':')
-      | ElnaLexerKind.hat:
-        write_c('^')
-      | ElnaLexerKind.at:
-        write_c('@')
-      | ElnaLexerKind.comment:
-        write_s("(* COMMENT *)")
-      | ElnaLexerKind.integer:
-        write_c('<');
-        write_i(cast(current_token: ^ElnaLexerIntegerToken)^.value);
-        write_c('>')
-      | ElnaLexerKind.word:
-        write_c('<');
-        write_i(cast(current_token: ^ElnaLexerIntegerToken)^.value);
-        write_s("u>")
-      | ElnaLexerKind.character:
-        write_c('<');
-        write_i(cast(cast(current_token: ^ElnaLexerCharacterToken)^.value: Int));
-        write_s("c>")
-      | ElnaLexerKind.string:
-        write_s("\"...\"")
-      | ElnaLexerKind._defer:
-        write_s("DEFER")
-      | ElnaLexerKind.exclamation:
-        write_c('!')
-      | ElnaLexerKind.arrow:
-        write_s("->")
-      | ElnaLexerKind._import:
-      write_s("IMPORT")
-      else
-        write_s("UNKNOWN<");
-        write_i(cast(current_token^.kind: Int));
-        write_c('>')
-    end;
-    write_c(' ');
-
-    i := i + 1u
-  end;
-  write_c('\n')
-return
-
-(*
-  Compilation entry.
-*)
-
-proc compile_in_stages#[T](command_line: ^CommandLine; source_code: SourceCode#[T]) -> Int
-var
-  return_code: Int := 0
-  lexer: Tokenizer
-begin
-  if command_line^.lex or command_line^.parse then
-    lexer := lexer_text(source_code)
-  end;
-  if command_line^.parse then
-    parse(lexer.data, lexer.length)
-  end
-return return_code
-
-proc process(argc: Int; argv: ^^Word8) -> Int
-var
-  tokens: ^ElnaLexerToken
-  tokens_size: Word
-  source_code: SourceCode#[SourceFile]
-  command_line: ^CommandLine
-  return_code: Int := 0
-  source_file: ^SourceFile
-begin
-  command_line := parse_command_line(argc, argv);
-  if command_line = nil then
-    return_code := 2
-  end;
-
-  if return_code = 0 then
-    source_file := read_source(command_line^.input);
-
-    if source_file = nil then
-      perror(command_line^.input);
-      return_code := 3
-    end
-  end;
-
-  if return_code = 0 then
-    defer
-      fclose(source_file^.handle)
-    end;
-
-    source_code.position := ElnaLocation{line: 1u, column: 1u};
-    source_code.input := source_file;
-    source_code.empty := source_file_empty;
-    source_code.head := source_file_head;
-    source_code.advance := source_file_advance;
-
-    return_code := compile_in_stages(command_line, source_code)
-  end
+proc compile_file(command_line: ^CommandLine) -> Int
+var
+	source_text: []const Word8
+	lexer_cursor: ElnaLexerCursor
+	error_list: ElnaList
+	parser_node: ^ElnaTreeModuleDeclaration
+	tac_module: ^ElnaInstructionModule
+	out_file: ^FILE := stdout
+	token: ^ElnaLexerToken
+	return_code: Int := 0
+begin
+	source_text := read_file_to_buffer(command_line^.input);
+
+	if command_line^.lex then
+		elna_lexer_initialize(@lexer_cursor, cast(source_text.ptr: ^Word8));
+		token := elna_lexer_read(@lexer_cursor);
+		while token^.kind <> ElnaLexerKind.eof do
+			token := elna_lexer_read(@lexer_cursor)
+		end
+	else
+		elna_list_initialize(@error_list);
+		elna_symbol_table_build();
+
+		elna_lexer_initialize(@lexer_cursor, cast(source_text.ptr: ^Word8));
+		parser_node := elna_parser_module_declaration(@lexer_cursor, @error_list);
+
+		if ~elna_list_empty(@error_list) then
+			print_errors(@error_list);
+			return_code := 1
+		elsif ~command_line^.parse then
+			elna_declaration_module_declaration(parser_node, @error_list);
+			if ~elna_list_empty(@error_list) then
+				print_errors(@error_list);
+				return_code := 1
+			else
+				elna_name_module_declaration(parser_node, @error_list);
+				if ~elna_list_empty(@error_list) then
+					print_errors(@error_list);
+					return_code := 1
+				else
+					elna_type_module_declaration(parser_node, @error_list);
+					if ~elna_list_empty(@error_list) then
+						print_errors(@error_list);
+						return_code := 1
+					else
+						tac_module := elna_tac_module_declaration(parser_node);
+
+						if command_line^.output <> nil then
+							out_file := fopen(command_line^.output, "wb\0".ptr);
+							if out_file = nil then
+								perror(command_line^.output);
+								return_code := 3
+							end
+						end;
+
+						if return_code = 0 then
+							elna_qbe_emit(tac_module, out_file);
+
+							if command_line^.output <> nil & out_file <> stdout then
+								fclose(out_file)
+							end
+						end
+					end
+				end
+			end
+		end
+	end
 return return_code
 
 proc initialize_global_state()
+begin
 	stdin := fdopen(0, "r\0".ptr);
 	stdout := fdopen(1, "w\0".ptr);
 	stderr := fdopen(2, "w\0".ptr)
 return
 
+proc process(argc: Int; argv: ^^Word8) -> Int
+var
+	command_line: ^CommandLine
+	return_code: Int := 0
+begin
+	command_line := parse_command_line(argc, argv);
+	if command_line = nil then
+		return_code := 2
+	elsif command_line^.input = nil then
+		write_s("Fatal error: no input file provided.\n");
+		return_code := 2
+	else
+		return_code := compile_file(command_line)
+	end
+return return_code
+
 begin
-  initialize_global_state();
+	initialize_global_state();
 
-  exit(process(cast(parameters.length: Int), parameters.ptr))
+	exit(process(cast(parameters.length: Int), parameters.ptr))
 end.
diff --git a/source/name_analysis.elna b/source/name_analysis.elna
new file mode 100644
index 0000000..75d6dbd
--- /dev/null
+++ b/source/name_analysis.elna
@@ -0,0 +1,539 @@
+(* 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/. *)
+module
+import common, cstdlib, lexer, ast, symbol, diagnostic
+
+proc elna_name_type_expression*(parser_node: ^ElnaTreeTypeExpression; error_list: ^ElnaList) -> ^ElnaType
+var
+	result: ^ElnaType := nil
+begin
+	if parser_node <> nil then
+		case parser_node^.kind of
+			ElnaTreeKind.named_type_expression:
+				result := elna_name_named_type_expression(cast(parser_node: ^ElnaTreeNamedTypeExpression), error_list)
+			| ElnaTreeKind.enumeration_type_expression:
+				result := malloc#[ElnaType](#size(ElnaTypeEnumeration));
+				result^.kind := ElnaTypeKind.enumeration;
+				elna_name_enumeration_type_expression(cast(parser_node: ^ElnaTreeEnumerationTypeExpression), error_list, cast(result: ^ElnaTypeEnumeration))
+			| ElnaTreeKind.record_type_expression:
+				result := malloc#[ElnaType](#size(ElnaTypeRecord));
+				result^.kind := ElnaTypeKind._record;
+				elna_name_record_type_expression(cast(parser_node: ^ElnaTreeRecordTypeExpression), error_list, cast(result: ^ElnaTypeRecord))
+			| ElnaTreeKind.pointer_type_expression:
+				result := malloc#[ElnaType](#size(ElnaTypePointer));
+				result^.kind := ElnaTypeKind.pointer;
+				elna_name_pointer_type_expression(cast(parser_node: ^ElnaTreePointerTypeExpression), error_list, cast(result: ^ElnaTypePointer))
+			| ElnaTreeKind.array_type_expression:
+				result := malloc#[ElnaType](#size(ElnaTypeArray));
+				result^.kind := ElnaTypeKind.array;
+				elna_name_array_type_expression(cast(parser_node: ^ElnaTreeArrayTypeExpression), error_list, cast(result: ^ElnaTypeArray))
+			else
+		end
+	end
+return result
+
+proc elna_name_named_type_expression*(parser_node: ^ElnaTreeNamedTypeExpression; error_list: ^ElnaList) -> ^ElnaType
+var
+	symbol_info: ^ElnaSymbolInfo
+	type_info: ^ElnaSymbolTypeInfo
+	undefined_symbol: ^ElnaErrorUndefinedSymbol
+	result: ^ElnaType := nil
+begin
+	symbol_info := elna_symbol_table_lookup(symbol_table_global, parser_node^.name);
+	if symbol_info <> nil then
+		type_info := cast(symbol_info: ^ElnaSymbolTypeInfo);
+		result := type_info^._type
+	else
+		undefined_symbol := elna_error_undefined_symbol_create(parser_node^.position, parser_node^.name);
+		elna_list_append(error_list, cast(undefined_symbol: ^ElnaListNode))
+	end
+return result
+
+proc elna_name_alias_type_expression*(parser_node: ^ElnaTreeNamedTypeExpression;
+		error_list: ^ElnaList; result: ^ElnaTypeAlias)
+var
+	base: ^ElnaType
+begin
+	base := elna_name_named_type_expression(parser_node, error_list);
+	if base <> nil then
+		result^.size := base^.size;
+		result^.alignment := base^.alignment;
+		result^.base := base
+	end
+return
+
+proc elna_name_enumeration_type_expression*(parser_node: ^ElnaTreeEnumerationTypeExpression;
+		error_list: ^ElnaList; result: ^ElnaTypeEnumeration)
+var
+	tree_member: ^ElnaTreeEnumeration
+	i: Word := 0u
+begin
+	result^.size := 8u;
+	result^.alignment := 8u;
+	result^.length := parser_node^.length;
+	result^.members := malloc#[[]const Word8](parser_node^.length * #size([]const Word8));
+
+	tree_member := parser_node^.members;
+	while i < parser_node^.length & tree_member <> nil do
+		(result^.members + i)^ := tree_member^.name;
+		tree_member := tree_member^.next;
+		i := i + 1u
+	end
+return
+
+proc elna_name_pointer_type_expression*(parser_node: ^ElnaTreePointerTypeExpression;
+		error_list: ^ElnaList; result: ^ElnaTypePointer)
+begin
+	result^.size := 8u;
+	result^.alignment := 8u;
+	result^.base := elna_name_type_expression(parser_node^.base, error_list)
+return
+
+proc elna_name_array_type_expression*(parser_node: ^ElnaTreeArrayTypeExpression;
+		error_list: ^ElnaList; result: ^ElnaTypeArray)
+var
+	base: ^ElnaType
+	len_lit: ^ElnaTreeIntegerLiteral
+begin
+	base := elna_name_type_expression(parser_node^.base, error_list);
+	len_lit := cast(parser_node^.length: ^ElnaTreeIntegerLiteral);
+	if base <> nil & len_lit <> nil then
+		result^.size := base^.size * len_lit^.value;
+		result^.alignment := base^.alignment;
+		result^.base := base;
+		result^.length := len_lit^.value
+	end
+return
+
+proc elna_name_record_type_expression*(parser_node: ^ElnaTreeRecordTypeExpression;
+		error_list: ^ElnaList; result: ^ElnaTypeRecord)
+var
+	tree_field: ^ElnaTreeField
+	member_array_current: ^ElnaTypeField
+	field_type: ^ElnaType
+begin
+	result^.size := 0u;
+	result^.alignment := 0u;
+	result^.length := 0u;
+	result^.members := malloc#[ElnaTypeField](parser_node^.length * #size(ElnaTypeField));
+
+	tree_field := parser_node^.members;
+	member_array_current := result^.members;
+
+	while result^.length < parser_node^.length & tree_field <> nil do
+		member_array_current^.name := tree_field^.name;
+		field_type := elna_name_type_expression(tree_field^.type_expression, error_list);
+		if field_type <> nil then
+			result^.size := result^.size + field_type^.size;
+			if field_type^.alignment > result^.alignment then
+				result^.alignment := field_type^.alignment
+			end;
+			member_array_current^.field_type := field_type;
+			member_array_current := member_array_current + 1u;
+			tree_field := tree_field^.next;
+			result^.length := result^.length + 1u
+		else
+			tree_field := nil
+		end
+	end
+return
+
+proc elna_name_procedure_temporary*(parser_node: ^ElnaTreeVariableDeclaration; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+var
+	info: ^ElnaSymbolTemporaryInfo
+	variable_type: ^ElnaType
+	declaration_error: ^ElnaErrorDuplicateDeclaration
+begin
+	info := cast(elna_symbol_table_lookup(symbol_table, parser_node^.name): ^ElnaSymbolTemporaryInfo);
+	if info = nil then
+		variable_type := elna_name_type_expression(parser_node^.type_expression, error_list);
+		info := elna_symbol_temporary_info_create(0u, variable_type);
+		elna_symbol_table_enter(symbol_table, parser_node^.name, cast(info: ^ElnaSymbolInfo))
+	else
+		declaration_error := elna_error_duplicate_declaration_create(parser_node^.position, parser_node^.name);
+		elna_list_append(error_list, cast(declaration_error: ^ElnaListNode))
+	end
+return
+
+proc elna_name_procedure_temporaries*(parser_node: ^ElnaTreeVariableDeclaration; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+var
+	current: ^ElnaTreeVariableDeclaration
+begin
+	current := parser_node;
+	while current <> nil do
+		elna_name_procedure_temporary(current, symbol_table, error_list);
+		current := cast(current^.next: ^ElnaTreeVariableDeclaration)
+	end
+return
+
+proc elna_name_type_declaration*(parser_node: ^ElnaTreeTypeDeclaration; error_list: ^ElnaList)
+var
+	type_info: ^ElnaSymbolTypeInfo
+	type_stub: ^ElnaType
+	type_expression: ^ElnaTreeTypeExpression
+begin
+	type_info := cast(elna_symbol_table_lookup(symbol_table_global, parser_node^.name): ^ElnaSymbolTypeInfo);
+	if type_info <> nil then
+		type_stub := type_info^._type;
+		type_expression := parser_node^.type_expression;
+
+		if type_stub^.kind = ElnaTypeKind.alias then
+			elna_name_alias_type_expression(cast(type_expression: ^ElnaTreeNamedTypeExpression), error_list, cast(type_stub: ^ElnaTypeAlias))
+		elsif type_stub^.kind = ElnaTypeKind.enumeration then
+			elna_name_enumeration_type_expression(cast(type_expression: ^ElnaTreeEnumerationTypeExpression), error_list, cast(type_stub: ^ElnaTypeEnumeration))
+		elsif type_stub^.kind = ElnaTypeKind._record then
+			elna_name_record_type_expression(cast(type_expression: ^ElnaTreeRecordTypeExpression), error_list, cast(type_stub: ^ElnaTypeRecord))
+		elsif type_stub^.kind = ElnaTypeKind.pointer then
+			elna_name_pointer_type_expression(cast(type_expression: ^ElnaTreePointerTypeExpression), error_list, cast(type_stub: ^ElnaTypePointer))
+		elsif type_stub^.kind = ElnaTypeKind.array then
+			elna_name_array_type_expression(cast(type_expression: ^ElnaTreeArrayTypeExpression), error_list, cast(type_stub: ^ElnaTypeArray))
+		end
+	end
+return
+
+proc elna_name_variable_expression*(parser_node: ^ElnaTreeVariableExpression; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+var
+	symbol_info: ^ElnaSymbolInfo
+	undefined_symbol: ^ElnaErrorUndefinedSymbol
+begin
+	symbol_info := elna_symbol_table_lookup(symbol_table, parser_node^.name);
+	if symbol_info = nil then
+		undefined_symbol := elna_error_undefined_symbol_create(parser_node^.position, parser_node^.name);
+		elna_list_append(error_list, cast(undefined_symbol: ^ElnaListNode))
+	end
+return
+
+proc elna_name_cast_expression*(parser_node: ^ElnaTreeCastExpression; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+begin
+	elna_name_binary_expression(parser_node^.expression, symbol_table, error_list);
+	parser_node^.type_decoration := elna_name_type_expression(parser_node^.type_expression, error_list)
+return
+
+proc elna_name_simple_expression*(parser_node: ^ElnaTreeExpression; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+begin
+	if parser_node^.kind = ElnaTreeKind._cast then
+		elna_name_cast_expression(cast(parser_node: ^ElnaTreeCastExpression), symbol_table, error_list)
+	elsif parser_node^.kind = ElnaTreeKind.variable_expression then
+		elna_name_variable_expression(cast(parser_node: ^ElnaTreeVariableExpression), symbol_table, error_list)
+	end
+return
+
+proc elna_name_call*(parser_node: ^ElnaTreeCall; symbol_table: ^ElnaSymbolTable; error_list: ^ElnaList)
+var
+	argument_tree: ^ElnaTreeExpressionList
+begin
+	elna_name_variable_expression(parser_node^.callee, symbol_table, error_list);
+	argument_tree := parser_node^.arguments;
+	while argument_tree <> nil do
+		elna_name_binary_expression(argument_tree^.expression, symbol_table, error_list);
+		argument_tree := argument_tree^.next
+	end
+return
+
+proc elna_name_dereference_expression*(parser_node: ^ElnaTreeDereferenceExpression; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+begin
+	elna_name_designator(parser_node^.pointer, symbol_table, error_list)
+return
+
+proc elna_name_field_access_expression*(parser_node: ^ElnaTreeFieldAccessExpression; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+var
+	variable_expression: ^ElnaTreeVariableExpression
+	identifier_symbol: ^ElnaSymbolInfo
+	type_info: ^ElnaSymbolTypeInfo
+	undefined_member_error: ^ElnaErrorUndefinedMember
+	enumeration_type: ^ElnaTypeEnumeration
+	member_count: Word
+	current_member: ^[]const Word8
+	found: Bool := false
+begin
+	if parser_node^.aggregate^.kind = ElnaTreeKind.variable_expression then
+		variable_expression := cast(parser_node^.aggregate: ^ElnaTreeVariableExpression);
+		identifier_symbol := elna_symbol_table_lookup(symbol_table, variable_expression^.name);
+
+		if identifier_symbol <> nil & identifier_symbol^.kind = ElnaSymbolInfoKind.type_info then
+			type_info := cast(identifier_symbol: ^ElnaSymbolTypeInfo);
+			if type_info^._type^.kind = ElnaTypeKind.enumeration then
+				enumeration_type := cast(type_info^._type: ^ElnaTypeEnumeration);
+				current_member := enumeration_type^.members;
+				member_count := enumeration_type^.length;
+
+				while member_count > 0u & ~found do
+					if current_member^ = parser_node^.field then
+						found := true
+					end;
+					member_count := member_count - 1u;
+					current_member := current_member + 1u
+				end
+			end;
+			if ~found then
+				undefined_member_error := elna_error_undefined_member_create(variable_expression^.position,
+						variable_expression^.name, parser_node^.field);
+				elna_list_append(error_list, cast(undefined_member_error: ^ElnaListNode))
+			end
+		else
+			elna_name_designator(cast(variable_expression: ^ElnaTreeExpression), symbol_table, error_list)
+		end
+	else
+		elna_name_designator(parser_node^.aggregate, symbol_table, error_list)
+	end
+return
+
+proc elna_name_array_access_expression*(parser_node: ^ElnaTreeArrayAccessExpression; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+begin
+	elna_name_designator(parser_node^.array, symbol_table, error_list);
+	elna_name_binary_expression(parser_node^.index, symbol_table, error_list)
+return
+
+proc elna_name_designator*(parser_node: ^ElnaTreeExpression; symbol_table: ^ElnaSymbolTable; error_list: ^ElnaList)
+begin
+	if parser_node^.kind = ElnaTreeKind.dereference_expression then
+		elna_name_dereference_expression(cast(parser_node: ^ElnaTreeDereferenceExpression), symbol_table, error_list)
+	elsif parser_node^.kind = ElnaTreeKind.field_access_expression then
+		elna_name_field_access_expression(cast(parser_node: ^ElnaTreeFieldAccessExpression), symbol_table, error_list)
+	elsif parser_node^.kind = ElnaTreeKind.array_access_expression then
+		elna_name_array_access_expression(cast(parser_node: ^ElnaTreeArrayAccessExpression), symbol_table, error_list)
+	elsif parser_node^.kind = ElnaTreeKind.call then
+		elna_name_call(cast(parser_node: ^ElnaTreeCall), symbol_table, error_list)
+	else
+		elna_name_simple_expression(parser_node, symbol_table, error_list)
+	end
+return
+
+proc elna_name_unary_expression*(parser_node: ^ElnaTreeExpression; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+var
+	unary_node: ^ElnaTreeUnaryExpression
+begin
+	if parser_node^.kind = ElnaTreeKind.unary_expression then
+		unary_node := cast(parser_node: ^ElnaTreeUnaryExpression);
+		elna_name_designator(unary_node^.operand, symbol_table, error_list)
+	else
+		elna_name_designator(parser_node, symbol_table, error_list)
+	end
+return
+
+proc elna_name_binary_expression*(parser_node: ^ElnaTreeExpression; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+var
+	bin_node: ^ElnaTreeBinaryExpression
+begin
+	if parser_node^.kind = ElnaTreeKind.binary_expression then
+		bin_node := cast(parser_node: ^ElnaTreeBinaryExpression);
+		elna_name_unary_expression(bin_node^.lhs, symbol_table, error_list);
+		elna_name_unary_expression(bin_node^.rhs, symbol_table, error_list)
+	else
+		elna_name_unary_expression(parser_node, symbol_table, error_list)
+	end
+return
+
+proc elna_name_conditional_statements*(parser_node: ^ElnaTreeConditionalStatements; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+var
+	current: ^ElnaTreeConditionalStatements
+begin
+	current := parser_node;
+	while current <> nil do
+		elna_name_binary_expression(current^.condition, symbol_table, error_list);
+		elna_name_statements(current^.statements, symbol_table, error_list);
+		current := current^.next
+	end
+return
+
+proc elna_name_if_statement*(parser_node: ^ElnaTreeIfStatement; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+begin
+	elna_name_conditional_statements(parser_node^.conditionals, symbol_table, error_list);
+	if parser_node^._else <> nil then
+		elna_name_statements(parser_node^._else, symbol_table, error_list)
+	end
+return
+
+proc elna_name_return_statement*(parser_node: ^ElnaTreeReturnStatement; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+begin
+	elna_name_binary_expression(parser_node^.returned, symbol_table, error_list)
+return
+
+proc elna_name_assign_statement*(parser_node: ^ElnaTreeAssignStatement; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+begin
+	elna_name_designator(parser_node^.assignee, symbol_table, error_list);
+	elna_name_binary_expression(parser_node^.assignment, symbol_table, error_list)
+return
+
+proc elna_name_statement*(parser_node: ^ElnaTreeStatement; symbol_table: ^ElnaSymbolTable; error_list: ^ElnaList)
+var
+	call_statement: ^ElnaTreeCallStatement
+begin
+	if parser_node^.kind = ElnaTreeKind.if_statement then
+		elna_name_if_statement(cast(parser_node: ^ElnaTreeIfStatement), symbol_table, error_list)
+	elsif parser_node^.kind = ElnaTreeKind.return_statement then
+		elna_name_return_statement(cast(parser_node: ^ElnaTreeReturnStatement), symbol_table, error_list)
+	elsif parser_node^.kind = ElnaTreeKind.call_statement then
+		call_statement := cast(parser_node: ^ElnaTreeCallStatement);
+		elna_name_call(call_statement^.call, symbol_table, error_list)
+	elsif parser_node^.kind = ElnaTreeKind.assign_statement then
+		elna_name_assign_statement(cast(parser_node: ^ElnaTreeAssignStatement), symbol_table, error_list)
+	end
+return
+
+proc elna_name_statements*(parser_node: ^ElnaTreeStatement; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+var
+	current: ^ElnaTreeStatement
+begin
+	current := parser_node;
+	while current <> nil do
+		elna_name_statement(current, symbol_table, error_list);
+		current := current^.next
+	end
+return
+
+proc elna_name_procedure_declaration*(parser_node: ^ElnaTreeProcedureDeclaration; error_list: ^ElnaList)
+var
+	new_symbol_table: ^ElnaSymbolTable
+	symbol_info: ^ElnaSymbolProcedureInfo
+	proc_type: ^ElnaTypeProcedure
+begin
+	symbol_info := cast(elna_symbol_table_lookup(symbol_table_global, parser_node^.name): ^ElnaSymbolProcedureInfo);
+
+	proc_type := malloc#[ElnaTypeProcedure](#size(ElnaTypeProcedure));
+	proc_type^.kind := ElnaTypeKind.procedure;
+	proc_type^.size := 8u;
+	proc_type^.alignment := 8u;
+	if parser_node^.return_type = nil then
+		proc_type^.return_type := nil
+	else
+		proc_type^.return_type := elna_name_type_expression(parser_node^.return_type, error_list)
+	end;
+	symbol_info^.procedure_type := proc_type;
+
+	if ~symbol_info^.is_extern 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, error_list);
+		elna_name_procedure_temporaries(parser_node^.temporaries, new_symbol_table, error_list);
+		elna_name_statements(parser_node^.body, new_symbol_table, error_list)
+	end
+return
+
+proc elna_name_program_body*(parser_node: ^ElnaTreeStatement)
+var
+	symbol_info: ^ElnaSymbolProcedureInfo
+begin
+	symbol_info := elna_symbol_procedure_info_create(false);
+	symbol_info^.symbol_table := elna_symbol_table_create(symbol_table_global);
+	elna_symbol_table_enter(symbol_table_global, "main", cast(symbol_info: ^ElnaSymbolInfo))
+return
+
+proc elna_declaration_type_declaration*(parser_node: ^ElnaTreeTypeDeclaration; error_list: ^ElnaList)
+var
+	type_info: ^ElnaSymbolTypeInfo
+	result: ^ElnaType := nil
+	type_expression: ^ElnaTreeTypeExpression
+	declaration_error: ^ElnaErrorDuplicateDeclaration
+begin
+	type_info := cast(elna_symbol_table_lookup(symbol_table_global, parser_node^.name): ^ElnaSymbolTypeInfo);
+
+	if type_info = nil then
+		type_expression := parser_node^.type_expression;
+
+		if type_expression^.kind = ElnaTreeKind.named_type_expression then
+			result := malloc#[ElnaType](#size(ElnaTypeAlias));
+			result^.kind := ElnaTypeKind.alias
+		elsif type_expression^.kind = ElnaTreeKind.enumeration_type_expression then
+			result := malloc#[ElnaType](#size(ElnaTypeEnumeration));
+			result^.kind := ElnaTypeKind.enumeration
+		elsif type_expression^.kind = ElnaTreeKind.record_type_expression then
+			result := malloc#[ElnaType](#size(ElnaTypeRecord));
+			result^.kind := ElnaTypeKind._record
+		elsif type_expression^.kind = ElnaTreeKind.pointer_type_expression then
+			result := malloc#[ElnaType](#size(ElnaTypePointer));
+			result^.kind := ElnaTypeKind.pointer
+		elsif type_expression^.kind = ElnaTreeKind.array_type_expression then
+			result := malloc#[ElnaType](#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, cast(type_info: ^ElnaSymbolInfo))
+	else
+		declaration_error := elna_error_duplicate_declaration_create(parser_node^.position, parser_node^.name);
+		elna_list_append(error_list, cast(declaration_error: ^ElnaListNode))
+	end
+return
+
+proc elna_declaration_procedure_declaration*(parser_node: ^ElnaTreeProcedureDeclaration; error_list: ^ElnaList)
+var
+	symbol_info: ^ElnaSymbolProcedureInfo
+	declaration_error: ^ElnaErrorDuplicateDeclaration
+begin
+	symbol_info := cast(elna_symbol_table_lookup(symbol_table_global, parser_node^.name): ^ElnaSymbolProcedureInfo);
+
+	if symbol_info = nil then
+		symbol_info := elna_symbol_procedure_info_create(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, cast(symbol_info: ^ElnaSymbolInfo))
+	else
+		declaration_error := elna_error_duplicate_declaration_create(parser_node^.position, parser_node^.name);
+		elna_list_append(error_list, cast(declaration_error: ^ElnaListNode))
+	end
+return
+
+proc elna_declaration_module_declaration*(parser_node: ^ElnaTreeModuleDeclaration; error_list: ^ElnaList)
+var
+	current_type: ^ElnaTreeDeclaration
+	current_proc: ^ElnaTreeDeclaration
+begin
+	current_type := parser_node^.types;
+	while current_type <> nil do
+		elna_declaration_type_declaration(cast(current_type: ^ElnaTreeTypeDeclaration), error_list);
+		current_type := current_type^.next
+	end;
+
+	current_proc := cast(parser_node^.procedures: ^ElnaTreeDeclaration);
+	while current_proc <> nil do
+		elna_declaration_procedure_declaration(cast(current_proc: ^ElnaTreeProcedureDeclaration), error_list);
+		current_proc := current_proc^.next
+	end
+return
+
+proc elna_name_module_declaration*(parser_node: ^ElnaTreeModuleDeclaration; error_list: ^ElnaList)
+var
+	current_type: ^ElnaTreeDeclaration
+	current_global: ^ElnaTreeVariableDeclaration
+	current_proc: ^ElnaTreeProcedureDeclaration
+begin
+	current_type := parser_node^.types;
+	while current_type <> nil do
+		elna_name_type_declaration(cast(current_type: ^ElnaTreeTypeDeclaration), error_list);
+		current_type := current_type^.next
+	end;
+
+	current_global := parser_node^.globals;
+	while current_global <> nil do
+		elna_name_procedure_temporary(current_global, symbol_table_global, error_list);
+		current_global := cast(current_global^.next: ^ElnaTreeVariableDeclaration)
+	end;
+
+	current_proc := parser_node^.procedures;
+	while current_proc <> nil do
+		elna_name_procedure_declaration(current_proc, error_list);
+		current_proc := cast(current_proc^.next: ^ElnaTreeProcedureDeclaration)
+	end;
+
+	if parser_node^.body <> nil then
+		elna_name_program_body(parser_node^.body)
+	end
+return
+
+end.
diff --git a/source/parser.elna b/source/parser.elna
new file mode 100644
index 0000000..30f79f8
--- /dev/null
+++ b/source/parser.elna
@@ -0,0 +1,1162 @@
+(* 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/. *)
+module
+import common, cstdlib, lexer, ast, diagnostic
+
+proc elna_parser_expect*(cursor: ^ElnaLexerCursor; expected: ElnaLexerKind; error_list: ^ElnaList) -> ^ElnaLexerToken
+var
+	token: ^ElnaLexerToken
+	parser_error: ^ElnaErrorUnexpectedToken
+begin
+	elna_lexer_skip_empty_lines(cursor);
+	token := elna_lexer_peek(cursor);
+
+	if token^.kind = expected then
+		token := elna_lexer_read(cursor)
+	else
+		token := nil;
+		parser_error := elna_error_unexpected_token_create(cursor, 1u);
+		parser_error^.expected[1] := expected;
+		elna_list_append(error_list, cast(parser_error: ^ElnaListNode))
+	end
+return token
+
+proc elna_parser_escape*(current_position: ^const Word8; result: ^Word8) -> Word
+var
+	parsed_length: Word
+	next_character: Word8
+	pos: ^const Word8
+begin
+	pos := current_position;
+	next_character := pos^;
+
+	if next_character = '\\' then
+		parsed_length := 2u;
+		pos := pos + 1u;
+		next_character := pos^;
+
+		if next_character = '\\' then
+			result^ := 92u8
+		elsif next_character = 'n' then
+			result^ := 10u8
+		elsif next_character = 't' then
+			result^ := 9u8
+		elsif next_character = 'f' then
+			result^ := 12u8
+		elsif next_character = 'r' then
+			result^ := 13u8
+		elsif next_character = 'v' then
+			result^ := 11u8
+		elsif next_character = '"' then
+			result^ := 34u8
+		elsif next_character = '\'' then
+			result^ := 39u8
+		elsif next_character = '0' then
+			result^ := 0u8
+		else
+			result^ := next_character
+		end
+	else
+		parsed_length := 1u;
+		result^ := next_character
+	end
+return parsed_length
+
+proc elna_parser_integer_literal*(cursor: ^ElnaLexerCursor) -> ^ElnaTreeIntegerLiteral
+var
+	token: ^ElnaLexerToken
+	result: ^ElnaTreeIntegerLiteral
+	i: Word := 1u
+	val: Word := 0u
+begin
+	result := malloc#[ElnaTreeIntegerLiteral](#size(ElnaTreeIntegerLiteral));
+	token := elna_lexer_read(cursor);
+	result^.kind := ElnaTreeKind.integer_literal;
+	result^.type_decoration := nil;
+	result^.position := token^.position;
+
+	while i <= token^.start.length do
+		val := val * 10u + cast(token^.start[i] - '0': Word);
+		i := i + 1u
+	end;
+	result^.value := val
+return result
+
+proc elna_parser_boolean_literal*(cursor: ^ElnaLexerCursor) -> ^ElnaTreeBooleanLiteral
+var
+	token: ^ElnaLexerToken
+	result: ^ElnaTreeBooleanLiteral
+begin
+	token := elna_lexer_read(cursor);
+	result := malloc#[ElnaTreeBooleanLiteral](#size(ElnaTreeBooleanLiteral));
+	result^.kind := ElnaTreeKind.boolean_literal;
+	result^.value := token^.start = "true";
+	result^.type_decoration := nil;
+	result^.position := token^.position
+return result
+
+proc elna_parser_nil_literal*(cursor: ^ElnaLexerCursor) -> ^ElnaTreeNilLiteral
+var
+	token: ^ElnaLexerToken
+	result: ^ElnaTreeNilLiteral
+begin
+	token := elna_lexer_read(cursor);
+	result := malloc#[ElnaTreeNilLiteral](#size(ElnaTreeNilLiteral));
+	result^.kind := ElnaTreeKind.null;
+	result^.type_decoration := nil;
+	result^.position := token^.position
+return result
+
+proc elna_parser_character_literal*(cursor: ^ElnaLexerCursor) -> ^ElnaTreeCharacterLiteral
+var
+	result: ^ElnaTreeCharacterLiteral
+	token: ^ElnaLexerToken
+begin
+	result := malloc#[ElnaTreeCharacterLiteral](#size(ElnaTreeCharacterLiteral));
+	token := elna_lexer_read(cursor);
+	result^.kind := ElnaTreeKind.character_literal;
+	result^.position := token^.position;
+	result^.type_decoration := nil;
+	elna_parser_escape(token^.start.ptr + 1u, @result^.value)
+return result
+
+proc elna_parser_variable_expression*(cursor: ^ElnaLexerCursor) -> ^ElnaTreeVariableExpression
+var
+	result: ^ElnaTreeVariableExpression
+	token: ^ElnaLexerToken
+begin
+	result := malloc#[ElnaTreeVariableExpression](#size(ElnaTreeVariableExpression));
+	token := elna_lexer_read(cursor);
+	result^.kind := ElnaTreeKind.variable_expression;
+	result^.name := token^.start;
+	result^.position := token^.position;
+	result^.type_decoration := nil
+return result
+
+proc elna_parser_string_literal*(cursor: ^ElnaLexerCursor) -> ^ElnaTreeStringLiteral
+var
+	result: ^ElnaTreeStringLiteral
+	token: ^ElnaLexerToken
+	current_position: ^const Word8
+	parsed_length: Word
+	parsed_total: Word
+	target_start, target_position: ^Word8
+begin
+	result := malloc#[ElnaTreeStringLiteral](#size(ElnaTreeStringLiteral));
+	token := elna_lexer_read(cursor);
+	target_start := malloc#[Word8](token^.start.length);
+	target_position := target_start;
+	current_position := token^.start.ptr + 1u;
+	parsed_total := 2u;
+
+	result^.kind := ElnaTreeKind.string_literal;
+	result^.position := token^.position;
+	result^.type_decoration := nil;
+
+	while parsed_total < token^.start.length do
+		parsed_length := elna_parser_escape(current_position, target_position);
+		current_position := current_position + parsed_length;
+		parsed_total := parsed_total + parsed_length;
+		target_position := target_position + 1u
+	end;
+	result^.value := target_start[1 to cast(target_position - target_start: Word)]
+return result
+
+proc elna_parser_trait_expression*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeTraitExpression
+var
+	result: ^ElnaTreeTraitExpression
+	token: ^ElnaLexerToken
+begin
+	result := malloc#[ElnaTreeTraitExpression](#size(ElnaTreeTraitExpression));
+	result^.kind := ElnaTreeKind.trait_expression;
+	token := elna_lexer_read(cursor);
+	result^.name := token^.start;
+	result^.position := token^.position;
+
+	if elna_parser_expect(cursor, ElnaLexerKind.left_paren, error_list) <> nil then
+		result^.argument := elna_parser_type_expression(cursor, error_list);
+		if result^.argument = nil then
+			result := free_and_nil(result)
+		elsif elna_parser_expect(cursor, ElnaLexerKind.right_paren, error_list) = nil then
+			result := free_and_nil(result)
+		end
+	else
+		result := free_and_nil(result)
+	end
+return result
+
+proc elna_parser_cast_expression*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeCastExpression
+var
+	result: ^ElnaTreeCastExpression := nil
+	token: ^ElnaLexerToken
+	start_location: ElnaLocation
+begin
+	token := elna_lexer_read(cursor);
+	start_location := token^.position.start_location;
+
+	if elna_parser_expect(cursor, ElnaLexerKind.left_paren, error_list) <> nil then
+		result := malloc#[ElnaTreeCastExpression](#size(ElnaTreeCastExpression));
+		result^.kind := ElnaTreeKind._cast;
+		result^.position.start_location := start_location;
+		result^.type_decoration := nil;
+		result^.expression := elna_parser_binary_expression(cursor, error_list);
+		if result^.expression = nil then
+			result := free_and_nil(result)
+		elsif elna_parser_expect(cursor, ElnaLexerKind.colon, error_list) = nil then
+			result := free_and_nil(result)
+		else
+			result^.type_expression := elna_parser_type_expression(cursor, error_list);
+			if result^.type_expression = nil then
+				result := free_and_nil(result)
+			else
+				token := elna_parser_expect(cursor, ElnaLexerKind.right_paren, error_list);
+				if token = nil then
+					result := free_and_nil(result)
+				else
+					result^.position.end_location := token^.position.end_location
+				end
+			end
+		end
+	end
+return result
+
+proc elna_parser_simple_expression*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeExpression
+var
+	token: ^ElnaLexerToken
+	result: ^ElnaTreeExpression := nil
+begin
+	token := elna_lexer_peek(cursor);
+	case token^.kind of
+		ElnaLexerKind.character:
+			result := cast(elna_parser_character_literal(cursor): ^ElnaTreeExpression)
+		| ElnaLexerKind.integer:
+			result := cast(elna_parser_integer_literal(cursor): ^ElnaTreeExpression)
+		| ElnaLexerKind.string:
+			result := cast(elna_parser_string_literal(cursor): ^ElnaTreeExpression)
+		| ElnaLexerKind.boolean:
+			result := cast(elna_parser_boolean_literal(cursor): ^ElnaTreeExpression)
+		| ElnaLexerKind.null:
+			result := cast(elna_parser_nil_literal(cursor): ^ElnaTreeExpression)
+		| ElnaLexerKind._cast:
+			result := cast(elna_parser_cast_expression(cursor, error_list): ^ElnaTreeExpression)
+		| ElnaLexerKind.trait:
+			result := cast(elna_parser_trait_expression(cursor, error_list): ^ElnaTreeExpression)
+		| ElnaLexerKind.identifier:
+			result := cast(elna_parser_variable_expression(cursor): ^ElnaTreeExpression)
+		else
+	end
+return result
+
+proc elna_parser_dereference_expression*(cursor: ^ElnaLexerCursor;
+		simple_expression: ^ElnaTreeExpression) -> ^ElnaTreeDereferenceExpression
+var
+	result: ^ElnaTreeDereferenceExpression
+	token: ^ElnaLexerToken
+begin
+	token := elna_lexer_read(cursor);
+	result := malloc#[ElnaTreeDereferenceExpression](#size(ElnaTreeDereferenceExpression));
+	result^.kind := ElnaTreeKind.dereference_expression;
+	result^.pointer := simple_expression;
+	result^.type_decoration := nil;
+	result^.position := token^.position
+return result
+
+proc elna_parser_field_access_expression*(cursor: ^ElnaLexerCursor;
+		aggregate: ^ElnaTreeExpression) -> ^ElnaTreeFieldAccessExpression
+var
+	result: ^ElnaTreeFieldAccessExpression
+	token: ^ElnaLexerToken
+begin
+	token := elna_lexer_read(cursor);
+	result := malloc#[ElnaTreeFieldAccessExpression](#size(ElnaTreeFieldAccessExpression));
+	result^.kind := ElnaTreeKind.field_access_expression;
+	result^.type_decoration := nil;
+	result^.aggregate := aggregate;
+	result^.position.start_location := token^.position.start_location;
+
+	token := elna_lexer_read(cursor);
+	result^.field := token^.start;
+	result^.position.end_location := token^.position.end_location
+return result
+
+proc elna_parser_array_access_expression*(cursor: ^ElnaLexerCursor;
+		array: ^ElnaTreeExpression; error_list: ^ElnaList) -> ^ElnaTreeArrayAccessExpression
+var
+	result: ^ElnaTreeArrayAccessExpression
+	token: ^ElnaLexerToken
+begin
+	token := elna_lexer_read(cursor);
+	result := malloc#[ElnaTreeArrayAccessExpression](#size(ElnaTreeArrayAccessExpression));
+	result^.kind := ElnaTreeKind.array_access_expression;
+	result^.type_decoration := nil;
+	result^.array := array;
+	result^.position.start_location := token^.position.start_location;
+
+	result^.index := elna_parser_binary_expression(cursor, error_list);
+	if result^.index = nil then
+		result := free_and_nil(result)
+	else
+		token := elna_parser_expect(cursor, ElnaLexerKind.right_square, error_list);
+		if token = nil then
+			result := free_and_nil(result)
+		else
+			result^.position.end_location := token^.position.end_location
+		end
+	end
+return result
+
+proc elna_parser_call*(cursor: ^ElnaLexerCursor; callee: ^ElnaTreeExpression; error_list: ^ElnaList) -> ^ElnaTreeCall
+var
+	result: ^ElnaTreeCall
+	argument_entry: ^ElnaTreeExpressionList
+	token: ^ElnaLexerToken
+	parser_error: ^ElnaErrorUnexpectedToken
+	reading_args: Bool := true
+begin
+	result := malloc#[ElnaTreeCall](#size(ElnaTreeCall));
+	result^.kind := ElnaTreeKind.call;
+	result^.type_decoration := nil;
+	result^.arguments := nil;
+	result^.count := 0u;
+	result^.callee := cast(callee: ^ElnaTreeVariableExpression);
+
+	token := elna_lexer_read(cursor);
+	result^.position.start_location := token^.position.start_location;
+	token := elna_lexer_peek(cursor);
+
+	if token^.kind = ElnaLexerKind.right_paren then
+		token := elna_lexer_read(cursor);
+		result^.position.end_location := token^.position.end_location
+	else
+		while reading_args do
+			if result^.arguments = nil then
+				result^.arguments := malloc#[ElnaTreeExpressionList](#size(ElnaTreeExpressionList));
+				argument_entry := result^.arguments
+			else
+				argument_entry^.next := malloc#[ElnaTreeExpressionList](#size(ElnaTreeExpressionList));
+				argument_entry := argument_entry^.next
+			end;
+			argument_entry^.next := nil;
+			argument_entry^.expression := elna_parser_binary_expression(cursor, error_list);
+			if argument_entry^.expression = nil then
+				result := free_and_nil(result);
+				reading_args := false
+			else
+				result^.count := result^.count + 1u;
+				token := elna_lexer_peek(cursor);
+				if token^.kind = ElnaLexerKind.comma then
+					elna_lexer_read(cursor)
+				elsif token^.kind = ElnaLexerKind.right_paren then
+					token := elna_lexer_read(cursor);
+					result^.position.end_location := token^.position.end_location;
+					reading_args := false
+				else
+					parser_error := elna_error_unexpected_token_create(cursor, 2u);
+					parser_error^.expected[1] := ElnaLexerKind.comma;
+					parser_error^.expected[2] := ElnaLexerKind.right_paren;
+					elna_list_append(error_list, cast(parser_error: ^ElnaListNode));
+					result := free_and_nil(result);
+					reading_args := false
+				end
+			end
+		end
+	end
+return result
+
+proc elna_parser_designator*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeExpression
+var
+	simple_expression: ^ElnaTreeExpression
+	token: ^ElnaLexerToken
+	continue_loop: Bool := true
+begin
+	simple_expression := elna_parser_simple_expression(cursor, error_list);
+	if simple_expression <> nil then
+		while continue_loop do
+			token := elna_lexer_peek(cursor);
+			if token^.kind = ElnaLexerKind.hat then
+				simple_expression := cast(elna_parser_dereference_expression(cursor, simple_expression): ^ElnaTreeExpression)
+			elsif token^.kind = ElnaLexerKind.dot then
+				simple_expression := cast(elna_parser_field_access_expression(cursor, simple_expression): ^ElnaTreeExpression)
+			elsif token^.kind = ElnaLexerKind.left_square then
+				simple_expression := cast(elna_parser_array_access_expression(cursor, simple_expression, error_list): ^ElnaTreeExpression);
+				if simple_expression = nil then
+					continue_loop := false
+				end
+			elsif token^.kind = ElnaLexerKind.left_paren then
+				simple_expression := cast(elna_parser_call(cursor, simple_expression, error_list): ^ElnaTreeExpression);
+				if simple_expression = nil then
+					continue_loop := false
+				end
+			else
+				continue_loop := false
+			end
+		end
+	end
+return simple_expression
+
+proc elna_parser_unary_expression*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeExpression
+var
+	unary_result: ^ElnaTreeUnaryExpression
+	result: ^ElnaTreeExpression
+	op_kind: ElnaLexerKind
+	has_op: Bool := false
+	token: ^ElnaLexerToken
+begin
+	token := elna_lexer_peek(cursor);
+	if token^.kind = ElnaLexerKind.at or token^.kind = ElnaLexerKind.minus or token^.kind = ElnaLexerKind.not then
+		op_kind := token^.kind;
+		has_op := true;
+		elna_lexer_read(cursor)
+	end;
+	result := elna_parser_designator(cursor, error_list);
+	if result <> nil & has_op then
+		unary_result := malloc#[ElnaTreeUnaryExpression](#size(ElnaTreeUnaryExpression));
+		unary_result^.kind := ElnaTreeKind.unary_expression;
+		unary_result^.operand := result;
+		unary_result^.operator := op_kind;
+		unary_result^.position := token^.position;
+		unary_result^.type_decoration := nil;
+		result := cast(unary_result: ^ElnaTreeExpression)
+	end
+return result
+
+proc elna_parser_binary_expression*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeExpression
+var
+	lhs_node: ^ElnaTreeExpression
+	rhs_node: ^ElnaTreeExpression := nil
+	bin_result: ^ElnaTreeBinaryExpression
+	token: ^ElnaLexerToken
+begin
+	lhs_node := elna_parser_unary_expression(cursor, error_list);
+	token := elna_lexer_peek(cursor);
+
+	case token^.kind of
+		ElnaLexerKind.plus,
+		ElnaLexerKind.minus,
+		ElnaLexerKind.multiplication,
+		ElnaLexerKind.and,
+		ElnaLexerKind._or,
+		ElnaLexerKind._xor,
+		ElnaLexerKind.equals,
+		ElnaLexerKind.remainder,
+		ElnaLexerKind.division,
+		ElnaLexerKind.less_than,
+		ElnaLexerKind.greater_than,
+		ElnaLexerKind.less_equal,
+		ElnaLexerKind.not_equal,
+		ElnaLexerKind.greater_equal:
+			elna_lexer_read(cursor);
+			rhs_node := elna_parser_unary_expression(cursor, error_list)
+		else
+	end;
+
+	if rhs_node <> nil then
+		bin_result := malloc#[ElnaTreeBinaryExpression](#size(ElnaTreeBinaryExpression));
+		bin_result^.kind := ElnaTreeKind.binary_expression;
+		bin_result^.lhs := lhs_node;
+		bin_result^.rhs := rhs_node;
+		bin_result^.operator := token^.kind;
+		bin_result^.position := token^.position;
+		bin_result^.type_decoration := nil;
+		lhs_node := cast(bin_result: ^ElnaTreeExpression)
+	end
+return lhs_node
+
+proc elna_parser_label_declaration*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeLabelDeclaration
+var
+	result: ^ElnaTreeLabelDeclaration
+	token: ^ElnaLexerToken
+begin
+	token := elna_lexer_read(cursor);
+	result := malloc#[ElnaTreeLabelDeclaration](#size(ElnaTreeLabelDeclaration));
+	result^.kind := ElnaTreeKind.label_declaration;
+	result^.next := nil;
+	result^.position.start_location := token^.position.start_location;
+
+	token := elna_parser_expect(cursor, ElnaLexerKind.identifier, error_list);
+	if token <> nil then
+		result^.label := token^.start;
+		result^.position.end_location := token^.position.end_location
+	else
+		result := free_and_nil(result)
+	end
+return result
+
+proc elna_parser_assign_statement*(cursor: ^ElnaLexerCursor; assignee: ^ElnaTreeExpression; error_list: ^ElnaList) -> ^ElnaTreeAssignStatement
+var
+	token: ^ElnaLexerToken
+	result: ^ElnaTreeAssignStatement
+begin
+	result := malloc#[ElnaTreeAssignStatement](#size(ElnaTreeAssignStatement));
+	result^.kind := ElnaTreeKind.assign_statement;
+	result^.next := nil;
+	result^.assignee := assignee;
+	result^.assignment := nil;
+
+	token := elna_parser_expect(cursor, ElnaLexerKind.assignment, error_list);
+	if token <> nil then
+		result^.position := token^.position;
+		result^.assignment := elna_parser_binary_expression(cursor, error_list)
+	end;
+	if result^.assignment = nil then
+		result := free_and_nil(result)
+	end
+return result
+
+proc elna_parser_return_statement*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeReturnStatement
+var
+	token: ^ElnaLexerToken
+	result: ^ElnaTreeReturnStatement
+begin
+	token := elna_lexer_read(cursor);
+	result := malloc#[ElnaTreeReturnStatement](#size(ElnaTreeReturnStatement));
+	result^.kind := ElnaTreeKind.return_statement;
+	result^.next := nil;
+	result^.position := token^.position;
+	result^.returned := elna_parser_binary_expression(cursor, error_list);
+	if result^.returned = nil then
+		result := free_and_nil(result)
+	end
+return result
+
+proc elna_parser_conditional_statements*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList;
+		block_keyword: ElnaLexerKind) -> ^ElnaTreeConditionalStatements
+var
+	result: ^ElnaTreeConditionalStatements
+begin
+	result := malloc#[ElnaTreeConditionalStatements](#size(ElnaTreeConditionalStatements));
+	elna_lexer_read(cursor);
+	result^.condition := elna_parser_binary_expression(cursor, error_list);
+	if result^.condition = nil then
+		result := free_and_nil(result)
+	else
+		if elna_parser_expect(cursor, block_keyword, error_list) <> nil then
+			result^.statements := elna_parser_statements(cursor, error_list)
+		end;
+		if elna_list_empty(error_list) then
+			result^.next := nil
+		else
+			result := free_and_nil(result)
+		end
+	end
+return result
+
+proc elna_parser_if_statement*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeIfStatement
+var
+	result: ^ElnaTreeIfStatement
+	previous_conditional: ^ElnaTreeConditionalStatements
+	next_conditional: ^ElnaTreeConditionalStatements
+	token: ^ElnaLexerToken
+	reading_elsif: Bool := true
+begin
+	token := elna_lexer_peek(cursor);
+	result := malloc#[ElnaTreeIfStatement](#size(ElnaTreeIfStatement));
+	result^.kind := ElnaTreeKind.if_statement;
+	result^.position := token^.position;
+	result^.next := nil;
+
+	previous_conditional := elna_parser_conditional_statements(cursor, error_list, ElnaLexerKind._then);
+	result^.conditionals := previous_conditional;
+
+	while reading_elsif do
+		token := elna_lexer_peek(cursor);
+		if token^.kind = ElnaLexerKind._elsif then
+			next_conditional := elna_parser_conditional_statements(cursor, error_list, ElnaLexerKind._then);
+			previous_conditional^.next := next_conditional;
+			previous_conditional := next_conditional
+		elsif token^.kind = ElnaLexerKind._else then
+			elna_lexer_read(cursor);
+			result^._else := elna_parser_statements(cursor, error_list);
+			reading_elsif := false
+		else
+			result^._else := nil;
+			reading_elsif := false
+		end
+	end;
+	elna_parser_expect(cursor, ElnaLexerKind._end, error_list)
+return result
+
+proc elna_parser_statement*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeStatement
+var
+	result: ^ElnaTreeStatement := nil
+	call_result: ^ElnaTreeCallStatement
+	designator: ^ElnaTreeExpression
+	token: ^ElnaLexerToken
+begin
+	token := elna_lexer_peek(cursor);
+	if token^.kind = ElnaLexerKind._if then
+		result := cast(elna_parser_if_statement(cursor, error_list): ^ElnaTreeStatement)
+	elsif token^.kind = ElnaLexerKind._return then
+		result := cast(elna_parser_return_statement(cursor, error_list): ^ElnaTreeStatement)
+	elsif token^.kind = ElnaLexerKind.dot then
+		result := cast(elna_parser_label_declaration(cursor, error_list): ^ElnaTreeStatement)
+	elsif token^.kind = ElnaLexerKind.identifier then
+		designator := elna_parser_designator(cursor, error_list);
+		if designator <> nil then
+			if designator^.kind <> ElnaTreeKind.call then
+				result := cast(elna_parser_assign_statement(cursor, designator, error_list): ^ElnaTreeStatement)
+			else
+				call_result := malloc#[ElnaTreeCallStatement](#size(ElnaTreeCallStatement));
+				call_result^.kind := ElnaTreeKind.call_statement;
+				call_result^.next := nil;
+				call_result^.call := cast(designator: ^ElnaTreeCall);
+				call_result^.position := designator^.position;
+				result := cast(call_result: ^ElnaTreeStatement)
+			end
+		end
+	end
+return result
+
+proc elna_parser_statements*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeStatement
+var
+	previous_statement: ^ElnaTreeStatement
+	next_statement: ^ElnaTreeStatement
+	first_statement: ^ElnaTreeStatement
+	token: ^ElnaLexerToken
+begin
+	elna_lexer_skip_empty_lines(cursor);
+	first_statement := elna_parser_statement(cursor, error_list);
+	previous_statement := first_statement;
+	if previous_statement <> nil then
+		token := elna_lexer_peek(cursor);
+		while token^.kind = ElnaLexerKind.semicolon & elna_list_empty(error_list) do
+			elna_lexer_read(cursor);
+			elna_lexer_skip_empty_lines(cursor);
+			next_statement := elna_parser_statement(cursor, error_list);
+			previous_statement^.next := next_statement;
+			previous_statement := next_statement;
+			token := elna_lexer_peek(cursor)
+		end
+	end;
+	elna_lexer_skip_empty_lines(cursor)
+return first_statement
+
+proc elna_parser_named_type_expression*(cursor: ^ElnaLexerCursor) -> ^ElnaTreeNamedTypeExpression
+var
+	result: ^ElnaTreeNamedTypeExpression
+	token: ^ElnaLexerToken
+begin
+	result := malloc#[ElnaTreeNamedTypeExpression](#size(ElnaTreeNamedTypeExpression));
+	token := elna_lexer_read(cursor);
+	result^.kind := ElnaTreeKind.named_type_expression;
+	result^.name := token^.start;
+	result^.position := token^.position
+return result
+
+proc elna_parser_pointer_type_expression*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreePointerTypeExpression
+var
+	result: ^ElnaTreePointerTypeExpression
+	token: ^ElnaLexerToken
+begin
+	token := elna_lexer_read(cursor);
+	result := malloc#[ElnaTreePointerTypeExpression](#size(ElnaTreePointerTypeExpression));
+	result^.kind := ElnaTreeKind.pointer_type_expression;
+	result^.base := elna_parser_type_expression(cursor, error_list);
+	result^.position := token^.position;
+	if result^.base = nil then
+		result := free_and_nil(result)
+	end
+return result
+
+proc elna_parser_array_type_expression*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeArrayTypeExpression
+var
+	result: ^ElnaTreeArrayTypeExpression
+	token: ^ElnaLexerToken
+begin
+	token := elna_lexer_read(cursor);
+	result := malloc#[ElnaTreeArrayTypeExpression](#size(ElnaTreeArrayTypeExpression));
+	result^.kind := ElnaTreeKind.array_type_expression;
+	result^.position.start_location := token^.position.start_location;
+
+	result^.length := elna_parser_binary_expression(cursor, error_list);
+	if result^.length = nil then
+		result := free_and_nil(result)
+	else
+		token := elna_parser_expect(cursor, ElnaLexerKind.right_square, error_list);
+		if token = nil then
+			result := free_and_nil(result)
+		else
+			result^.base := elna_parser_type_expression(cursor, error_list);
+			if result^.base = nil then
+				result := free_and_nil(result)
+			else
+				result^.position.end_location := token^.position.end_location
+			end
+		end
+	end
+return result
+
+proc elna_parser_record_type_expression*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeRecordTypeExpression
+var
+	entry: ^ElnaTreeField
+	result: ^ElnaTreeRecordTypeExpression
+	previous_entry: ^ElnaTreeField
+	token: ^ElnaLexerToken
+	parser_error: ^ElnaErrorUnexpectedToken
+	reading_members: Bool := true
+begin
+	token := elna_lexer_read(cursor);
+	result := malloc#[ElnaTreeRecordTypeExpression](#size(ElnaTreeRecordTypeExpression));
+	result^.kind := ElnaTreeKind.record_type_expression;
+	result^.members := nil;
+	result^.length := 0u;
+	result^.position := token^.position;
+
+	token := elna_lexer_peek(cursor);
+	if token^.kind = ElnaLexerKind.left_paren then
+		elna_lexer_read(cursor);
+		token := elna_parser_expect(cursor, ElnaLexerKind.identifier, error_list);
+		if token = nil then
+			result := free_and_nil(result);
+			reading_members := false
+		else
+			result^.parent := token^.start;
+			if elna_parser_expect(cursor, ElnaLexerKind.right_paren, error_list) = nil then
+				result := free_and_nil(result);
+				reading_members := false
+			end
+		end
+	end;
+
+	while reading_members & result <> nil do
+		token := elna_lexer_read(cursor);
+		if token^.kind = ElnaLexerKind._end then
+			reading_members := false
+		elsif token^.kind <> ElnaLexerKind.identifier then
+			parser_error := elna_error_unexpected_token_create(cursor, 2u);
+			parser_error^.expected[1] := ElnaLexerKind._end;
+			parser_error^.expected[2] := ElnaLexerKind.identifier;
+			elna_list_append(error_list, cast(parser_error: ^ElnaListNode));
+			result := free_and_nil(result);
+			reading_members := false
+		else
+			entry := malloc#[ElnaTreeField](#size(ElnaTreeField));
+			result^.length := result^.length + 1u;
+			entry^.name := token^.start;
+			if elna_parser_expect(cursor, ElnaLexerKind.colon, error_list) = nil then
+				result := free_and_nil(result);
+				reading_members := false
+			else
+				entry^.type_expression := elna_parser_type_expression(cursor, error_list);
+				if entry^.type_expression = nil then
+					result := free_and_nil(result);
+					reading_members := false
+				else
+					entry^.next := nil;
+					if result^.members = nil then
+						result^.members := entry
+					else
+						previous_entry^.next := entry
+					end;
+					previous_entry := entry;
+
+					token := elna_lexer_read(cursor);
+					if token^.kind = ElnaLexerKind.semicolon then
+						(* continue *)
+					elsif token^.kind = ElnaLexerKind._end then
+						reading_members := false
+					else
+						parser_error := elna_error_unexpected_token_create(cursor, 2u);
+						parser_error^.expected[1] := ElnaLexerKind._end;
+						parser_error^.expected[2] := ElnaLexerKind.semicolon;
+						elna_list_append(error_list, cast(parser_error: ^ElnaListNode));
+						reading_members := false
+					end
+				end
+			end
+		end
+	end
+return result
+
+proc elna_parser_enumeration_type_expression*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeEnumerationTypeExpression
+var
+	result: ^ElnaTreeEnumerationTypeExpression
+	entry: ^ElnaTreeEnumeration
+	previous_entry: ^ElnaTreeEnumeration
+	token: ^ElnaLexerToken
+	parser_error: ^ElnaErrorUnexpectedToken
+	reading_members: Bool := true
+begin
+	token := elna_lexer_read(cursor);
+	result := malloc#[ElnaTreeEnumerationTypeExpression](#size(ElnaTreeEnumerationTypeExpression));
+	result^.kind := ElnaTreeKind.enumeration_type_expression;
+	result^.members := nil;
+	result^.length := 0u;
+	result^.position.start_location := token^.position.start_location;
+
+	while reading_members & result <> nil do
+		token := elna_parser_expect(cursor, ElnaLexerKind.identifier, error_list);
+		if token = nil then
+			result := free_and_nil(result);
+			reading_members := false
+		else
+			entry := malloc#[ElnaTreeEnumeration](#size(ElnaTreeEnumeration));
+			result^.length := result^.length + 1u;
+			entry^.name := token^.start;
+			entry^.next := nil;
+			if result^.members = nil then
+				result^.members := entry
+			else
+				previous_entry^.next := entry
+			end;
+			previous_entry := entry;
+
+			token := elna_lexer_peek(cursor);
+			if token^.kind = ElnaLexerKind.comma then
+				elna_lexer_read(cursor)
+			elsif token^.kind = ElnaLexerKind.right_paren then
+				token := elna_lexer_read(cursor);
+				result^.position.end_location := token^.position.end_location;
+				reading_members := false
+			else
+				parser_error := elna_error_unexpected_token_create(cursor, 2u);
+				parser_error^.expected[1] := ElnaLexerKind.comma;
+				parser_error^.expected[2] := ElnaLexerKind.right_paren;
+				elna_list_append(error_list, cast(parser_error: ^ElnaListNode));
+				result := free_and_nil(result);
+				reading_members := false
+			end
+		end
+	end
+return result
+
+proc elna_parser_type_expression*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeTypeExpression
+var
+	result: ^ElnaTreeTypeExpression := nil
+	token: ^ElnaLexerToken
+	parser_error: ^ElnaErrorUnexpectedToken
+begin
+	token := elna_lexer_peek(cursor);
+	if token^.kind = ElnaLexerKind.identifier then
+		result := cast(elna_parser_named_type_expression(cursor): ^ElnaTreeTypeExpression)
+	elsif token^.kind = ElnaLexerKind.left_paren then
+		result := cast(elna_parser_enumeration_type_expression(cursor, error_list): ^ElnaTreeTypeExpression)
+	elsif token^.kind = ElnaLexerKind._record then
+		result := cast(elna_parser_record_type_expression(cursor, error_list): ^ElnaTreeTypeExpression)
+	elsif token^.kind = ElnaLexerKind.hat then
+		result := cast(elna_parser_pointer_type_expression(cursor, error_list): ^ElnaTreeTypeExpression)
+	elsif token^.kind = ElnaLexerKind.left_square then
+		result := cast(elna_parser_array_type_expression(cursor, error_list): ^ElnaTreeTypeExpression)
+	else
+		parser_error := elna_error_unexpected_token_create(cursor, 5u);
+		parser_error^.expected[1] := ElnaLexerKind.identifier;
+		parser_error^.expected[2] := ElnaLexerKind.left_paren;
+		parser_error^.expected[3] := ElnaLexerKind._record;
+		parser_error^.expected[4] := ElnaLexerKind.hat;
+		parser_error^.expected[5] := ElnaLexerKind.left_square;
+		elna_list_append(error_list, cast(parser_error: ^ElnaListNode))
+	end
+return result
+
+proc elna_parser_variable_declaration*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeVariableDeclaration
+var
+	var_type: ^ElnaTreeTypeExpression
+	result: ^ElnaTreeVariableDeclaration := nil
+	token: ^ElnaLexerToken
+begin
+	token := elna_parser_expect(cursor, ElnaLexerKind.identifier, error_list);
+	if token <> nil then
+		if elna_parser_expect(cursor, ElnaLexerKind.colon, error_list) <> nil then
+			var_type := elna_parser_type_expression(cursor, error_list);
+			if var_type <> nil then
+				result := malloc#[ElnaTreeVariableDeclaration](#size(ElnaTreeVariableDeclaration));
+				result^.kind := ElnaTreeKind.variable_declaration;
+				result^.next := nil;
+				result^.name := token^.start;
+				result^.type_expression := var_type;
+				result^.position := token^.position
+			end
+		end
+	end
+return result
+
+proc elna_parser_parameters*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeVariableDeclaration
+var
+	parameters: ^ElnaTreeVariableDeclaration := nil
+	token: ^ElnaLexerToken
+	current_declaration: ^ElnaTreeVariableDeclaration
+	next_declaration: ^ElnaTreeVariableDeclaration
+	reading: Bool := true
+begin
+	token := elna_lexer_peek(cursor);
+	if token^.kind <> ElnaLexerKind.right_paren then
+		while reading do
+			next_declaration := elna_parser_variable_declaration(cursor, error_list);
+			if next_declaration = nil then
+				parameters := free_and_nil(parameters);
+				reading := false
+			else
+				if parameters = nil then
+					parameters := next_declaration
+				else
+					current_declaration^.next := cast(next_declaration: ^ElnaTreeDeclaration)
+				end;
+				current_declaration := next_declaration;
+
+				token := elna_lexer_peek(cursor);
+				if token^.kind = ElnaLexerKind.comma or token^.kind = ElnaLexerKind.semicolon then
+					elna_lexer_read(cursor)
+				else
+					reading := false
+				end
+			end
+		end
+	end
+return parameters
+
+proc elna_parser_procedure_declaration*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeProcedureDeclaration
+var
+	result: ^ElnaTreeProcedureDeclaration
+	token: ^ElnaLexerToken
+begin
+	token := elna_lexer_read(cursor);
+	result := malloc#[ElnaTreeProcedureDeclaration](#size(ElnaTreeProcedureDeclaration));
+	result^.kind := ElnaTreeKind.procedure_declaration;
+	result^.next := nil;
+	result^.position := token^.position;
+
+	token := elna_parser_expect(cursor, ElnaLexerKind.identifier, error_list);
+	if token = nil then
+		result := free_and_nil(result)
+	else
+		result^.name := token^.start;
+
+		if elna_parser_expect(cursor, ElnaLexerKind.left_paren, error_list) = nil then
+			result := free_and_nil(result)
+		else
+			result^.parameters := elna_parser_parameters(cursor, error_list);
+			if elna_list_empty(error_list) = false then
+				result := free_and_nil(result)
+			elsif elna_parser_expect(cursor, ElnaLexerKind.right_paren, error_list) = nil then
+				result := free_and_nil(result)
+			else
+				token := elna_lexer_peek(cursor);
+				if token^.kind = ElnaLexerKind.arrow then
+					elna_lexer_read(cursor);
+					result^.return_type := elna_parser_type_expression(cursor, error_list);
+					if result^.return_type = nil then
+						result := free_and_nil(result)
+					end
+				else
+					result^.return_type := nil
+				end;
+
+				if result <> nil then
+					token := elna_lexer_peek(cursor);
+					result^.is_extern := token^.kind = ElnaLexerKind._extern;
+					if result^.is_extern then
+						elna_lexer_read(cursor);
+						result^.temporaries := nil;
+						result^.body := nil
+					else
+						result^.temporaries := elna_parser_var_part(cursor, error_list);
+						if elna_list_empty(error_list) = false then
+							result := free_and_nil(result)
+						else
+							token := elna_lexer_peek(cursor);
+							if token^.kind = ElnaLexerKind._begin then
+								elna_lexer_read(cursor);
+								result^.body := elna_parser_statements(cursor, error_list);
+								if elna_list_empty(error_list) = false then
+									result := free_and_nil(result)
+								elsif elna_parser_expect(cursor, ElnaLexerKind._end, error_list) = nil then
+									result := free_and_nil(result)
+								end
+							elsif token^.kind = ElnaLexerKind._return then
+								result^.body := cast(elna_parser_return_statement(cursor, error_list): ^ElnaTreeStatement);
+								if result^.body = nil then
+									result := free_and_nil(result)
+								end
+							end
+						end
+					end
+				end
+			end
+		end
+	end
+return result
+
+proc elna_parser_procedures*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeProcedureDeclaration
+var
+	parser_node: ^ElnaTreeProcedureDeclaration
+	result: ^ElnaTreeProcedureDeclaration := nil
+	current_declaration: ^ElnaTreeProcedureDeclaration
+	token: ^ElnaLexerToken
+	reading: Bool := true
+begin
+	while reading do
+		elna_lexer_skip_empty_lines(cursor);
+		token := elna_lexer_peek(cursor);
+		if token^.kind = ElnaLexerKind._proc then
+			parser_node := elna_parser_procedure_declaration(cursor, error_list);
+			if parser_node <> nil then
+				if result = nil then
+					result := parser_node
+				else
+					current_declaration^.next := cast(parser_node: ^ElnaTreeDeclaration)
+				end;
+				current_declaration := parser_node
+			else
+				reading := false
+			end
+		else
+			reading := false
+		end
+	end
+return result
+
+proc elna_parser_type_declaration*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeTypeDeclaration
+var
+	result: ^ElnaTreeTypeDeclaration
+	token: ^ElnaLexerToken
+begin
+	token := elna_lexer_read(cursor);
+	result := malloc#[ElnaTreeTypeDeclaration](#size(ElnaTreeTypeDeclaration));
+	result^.kind := ElnaTreeKind.type_declaration;
+	result^.next := nil;
+	result^.name := token^.start;
+	result^.position := token^.position;
+
+	if elna_parser_expect(cursor, ElnaLexerKind.equals, error_list) <> nil then
+		result^.type_expression := elna_parser_type_expression(cursor, error_list)
+	else
+		result := free_and_nil(result)
+	end
+return result
+
+proc elna_parser_type_part*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeDeclaration
+var
+	parser_node: ^ElnaTreeDeclaration
+	result: ^ElnaTreeDeclaration := nil
+	current_declaration: ^ElnaTreeDeclaration
+	token: ^ElnaLexerToken
+	reading: Bool := true
+begin
+	elna_lexer_skip_empty_lines(cursor);
+	token := elna_lexer_peek(cursor);
+	if token^.kind = ElnaLexerKind._type then
+		elna_lexer_read(cursor);
+		while reading do
+			elna_lexer_skip_empty_lines(cursor);
+			token := elna_lexer_peek(cursor);
+			if token^.kind = ElnaLexerKind.identifier then
+				parser_node := cast(elna_parser_type_declaration(cursor, error_list): ^ElnaTreeDeclaration);
+				if parser_node <> nil then
+					if result = nil then
+						result := parser_node
+					else
+						current_declaration^.next := parser_node
+					end;
+					current_declaration := parser_node;
+					token := elna_lexer_peek(cursor);
+					if token^.kind = ElnaLexerKind.semicolon then
+						elna_lexer_read(cursor)
+					end
+				else
+					reading := false
+				end
+			else
+				reading := false
+			end
+		end
+	end
+return result
+
+proc elna_parser_var_part*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeVariableDeclaration
+var
+	result: ^ElnaTreeVariableDeclaration := nil
+	variable_node: ^ElnaTreeVariableDeclaration
+	current_declaration: ^ElnaTreeVariableDeclaration
+	token: ^ElnaLexerToken
+	reading: Bool := true
+begin
+	token := elna_lexer_peek(cursor);
+	if token^.kind = ElnaLexerKind._var then
+		elna_lexer_read(cursor);
+		while reading do
+			elna_lexer_skip_empty_lines(cursor);
+			token := elna_lexer_peek(cursor);
+			if token^.kind = ElnaLexerKind.identifier then
+				variable_node := elna_parser_variable_declaration(cursor, error_list);
+				if variable_node <> nil then
+					if result = nil then
+						result := variable_node
+					else
+						current_declaration^.next := cast(variable_node: ^ElnaTreeDeclaration)
+					end;
+					current_declaration := variable_node;
+					token := elna_lexer_peek(cursor);
+					if token^.kind = ElnaLexerKind.semicolon then
+						elna_lexer_read(cursor)
+					end
+				else
+					reading := false
+				end
+			else
+				reading := false
+			end
+		end
+	end
+return result
+
+proc elna_parser_program_body*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeStatement
+var
+	result: ^ElnaTreeStatement := nil
+	token: ^ElnaLexerToken
+begin
+	elna_lexer_skip_empty_lines(cursor);
+	token := elna_lexer_peek(cursor);
+	if token^.kind = ElnaLexerKind._begin then
+		elna_lexer_read(cursor);
+		result := elna_parser_statements(cursor, error_list);
+		if elna_parser_expect(cursor, ElnaLexerKind._end, error_list) = nil then
+			result := free_and_nil(result)
+		elsif elna_parser_expect(cursor, ElnaLexerKind.dot, error_list) = nil then
+			result := free_and_nil(result)
+		end
+	elsif token^.kind = ElnaLexerKind._end then
+		elna_lexer_read(cursor);
+		if elna_parser_expect(cursor, ElnaLexerKind.dot, error_list) = nil then
+			result := free_and_nil(result)
+		end
+	end
+return result
+
+proc elna_parser_module_declaration*(cursor: ^ElnaLexerCursor; error_list: ^ElnaList) -> ^ElnaTreeModuleDeclaration
+var
+	result: ^ElnaTreeModuleDeclaration
+begin
+	result := malloc#[ElnaTreeModuleDeclaration](#size(ElnaTreeModuleDeclaration));
+	result^.kind := ElnaTreeKind.module_declaration;
+	result^.position.start_location := ElnaLocation{ line: 1u, column: 1u };
+	result^.position.end_location := result^.position.start_location;
+
+	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);
+		if elna_list_empty(error_list) = false then
+			result := free_and_nil(result)
+		end
+	end;
+
+	if result <> nil then
+		result^.procedures := elna_parser_procedures(cursor, error_list);
+		if elna_list_empty(error_list) = false then
+			result := free_and_nil(result)
+		end
+	end;
+
+	if result <> nil then
+		result^.body := elna_parser_program_body(cursor, error_list);
+		if elna_list_empty(error_list) = false then
+			result := free_and_nil(result)
+		end
+	end
+return result
+
+end.
diff --git a/source/qbe.elna b/source/qbe.elna
new file mode 100644
index 0000000..0a5a45b
--- /dev/null
+++ b/source/qbe.elna
@@ -0,0 +1,635 @@
+(* 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/. *)
+module
+import common, cstdlib, cstdio, cstring, lexer, ast, symbol, tac
+
+var
+	qbe_unique_id: Word := 0u
+
+proc qbe_write_slice(file: ^FILE; text: []const Word8)
+begin
+	fwrite#[Word8](text.ptr, 1u, text.length, file)
+return
+
+proc qbe_write_str(file: ^FILE; str: ^const Word8)
+begin
+	fwrite#[Word8](str, 1u, strlen(str), file)
+return
+
+proc qbe_write_word(file: ^FILE; val: Word)
+var
+	buf: [32]Word8
+	len: Int
+begin
+	len := sprintf(@buf[1], "%u\0".ptr, val);
+	fwrite#[Word8](@buf[1], 1u, cast(len: Word), file)
+return
+
+proc is_global(globals: ^ElnaTacStaticVariable; name: []const Word8) -> Bool
+var
+	current: ^ElnaTacStaticVariable
+	found: Bool := false
+begin
+	current := globals;
+	while current <> nil & ~found do
+		if current^.name = name then
+			found := true
+		else
+			current := current^.next
+		end
+	end
+return found
+
+proc is_string_constant(strings: ^ElnaTacStringConstant; name: []const Word8) -> Bool
+var
+	current: ^ElnaTacStringConstant
+	found: Bool := false
+begin
+	current := strings;
+	while current <> nil & ~found do
+		if current^.name = name then
+			found := true
+		else
+			current := current^.next
+		end
+	end
+return found
+
+proc is_pointer_type(_type: ^ElnaType) -> Bool
+var
+	result: Bool := false
+begin
+	if _type <> nil then
+		if _type^.kind = ElnaTypeKind.pointer then
+			result := true
+		elsif _type = pointer_type then
+			result := true
+		end
+	end
+return result
+
+proc get_procedure_return_type(proc_name: []const Word8) -> ^ElnaType
+var
+	symbol_info: ^ElnaSymbolInfo
+	procedure_info: ^ElnaSymbolProcedureInfo
+	result: ^ElnaType := nil
+begin
+	symbol_info := elna_symbol_table_lookup(symbol_table_global, proc_name);
+	if symbol_info <> nil & symbol_info^.kind = ElnaSymbolInfoKind.procedure_info then
+		procedure_info := cast(symbol_info: ^ElnaSymbolProcedureInfo);
+		if procedure_info^.procedure_type <> nil then
+			result := procedure_info^.procedure_type^.return_type
+		end
+	end
+return result
+
+proc get_param_type(sym_table: ^ElnaSymbolTable; param_name: []const Word8) -> ^ElnaType
+var
+	symbol_info: ^ElnaSymbolInfo
+	temp_info: ^ElnaSymbolTemporaryInfo
+	result: ^ElnaType := nil
+begin
+	symbol_info := elna_symbol_table_lookup(sym_table, param_name);
+	if symbol_info <> nil & symbol_info^.kind = ElnaSymbolInfoKind.temporary_info then
+		temp_info := cast(symbol_info: ^ElnaSymbolTemporaryInfo);
+		result := temp_info^.variable_type
+	end
+return result
+
+proc is_pointer_operand(op: ^ElnaTacOperand; sym_table: ^ElnaSymbolTable;
+		globals: ^ElnaTacStaticVariable; strings: ^ElnaTacStringConstant) -> Bool
+var
+	var_type: ^ElnaType
+	result: Bool := false
+begin
+	if op^.kind = ElnaTacKind.variable then
+		if is_global(globals, op^.name) or is_string_constant(strings, op^.name) then
+			result := true
+		else
+			var_type := get_param_type(sym_table, op^.name);
+			if is_pointer_type(var_type) then
+				result := true
+			end
+		end
+	end
+return result
+
+proc qbe_emit_operand(file: ^FILE; op: ^ElnaTacOperand;
+		globals: ^ElnaTacStaticVariable; strings: ^ElnaTacStringConstant)
+begin
+	case op^.kind of
+		ElnaTacKind.constant:
+			qbe_write_word(file, op^.constant)
+		| ElnaTacKind.variable:
+			if is_global(globals, op^.name) or is_string_constant(strings, op^.name) then
+				qbe_write_str(file, "$\0".ptr)
+			else
+				qbe_write_str(file, "%\0".ptr)
+			end;
+			qbe_write_slice(file, op^.name)
+		| ElnaTacKind.label:
+			qbe_write_str(file, "@\0".ptr);
+			qbe_write_slice(file, op^.name)
+		else
+	end
+return
+
+proc var_needs_stack_alloc(instructions: ^ElnaList; sym_table: ^ElnaSymbolTable; name: []const Word8) -> Bool
+var
+	node: ^ElnaListNode
+	inst: ^ElnaTacInstruction
+	var_type: ^ElnaType
+	result: Bool := false
+begin
+	var_type := get_param_type(sym_table, name);
+	if var_type <> nil then
+		if var_type^.kind = ElnaTypeKind._record or var_type^.kind = ElnaTypeKind.array then
+			result := true
+		end
+	end;
+
+	node := instructions^.first;
+	while node <> nil & ~result do
+		inst := cast(node: ^ElnaTacInstruction);
+		if inst^.operator = ElnaTacOperator.get_address & inst^.operands[1].name = name then
+			result := true
+		elsif inst^.operator = ElnaTacOperator.copy_to_offset & inst^.operands[2].name = name then
+			result := true
+		elsif inst^.operator = ElnaTacOperator.copy_from_offset & inst^.operands[1].name = name then
+			result := true
+		end;
+		node := node^.next
+	end
+return result
+
+proc qbe_emit_procedure(file: ^FILE; proc_node: ^ElnaTacProcedure;
+		globals: ^ElnaTacStaticVariable; strings: ^ElnaTacStringConstant)
+var
+	node: ^ElnaListNode
+	inst: ^ElnaTacInstruction
+	ret_type: ^ElnaType
+	param_idx: Word := 0u
+	param_name: []const Word8
+	param_type: ^ElnaType
+	entry: ^ElnaSymbolEntry
+	temp_info: ^ElnaSymbolTemporaryInfo
+	sym_idx: Word := 0u
+	alloc_size: Word
+	last_operator: ElnaTacOperator := ElnaTacOperator.nop
+	tid: Word
+	arg_i: Word
+	arg_op: ^ElnaTacOperand
+	callee_ret: ^ElnaType
+	scaled: Word
+begin
+	qbe_write_str(file, "export function \0".ptr);
+	ret_type := get_procedure_return_type(proc_node^.name);
+
+	if proc_node^.name = "main" then
+		qbe_write_str(file, "w \0".ptr)
+	elsif ret_type <> nil then
+		if ret_type = bool_type then
+			qbe_write_str(file, "w \0".ptr)
+		else
+			qbe_write_str(file, "l \0".ptr)
+		end
+	end;
+
+	qbe_write_str(file, "$\0".ptr);
+	qbe_write_slice(file, proc_node^.name);
+	qbe_write_str(file, "(\0".ptr);
+
+	while param_idx < proc_node^.count do
+		param_name := (proc_node^.parameters + param_idx)^;
+		param_type := get_param_type(proc_node^.symbol_table, param_name);
+		if param_type = bool_type then
+			qbe_write_str(file, "w %\0".ptr)
+		else
+			qbe_write_str(file, "l %\0".ptr)
+		end;
+		qbe_write_slice(file, param_name);
+		if param_idx + 1u < proc_node^.count then
+			qbe_write_str(file, ", \0".ptr)
+		end;
+		param_idx := param_idx + 1u
+	end;
+
+	qbe_write_str(file, ") {\n@start\n\0".ptr);
+
+	(* Stack allocate variables needing memory address *)
+	if proc_node^.symbol_table <> nil then
+		while sym_idx < proc_node^.symbol_table^.count do
+			entry := proc_node^.symbol_table^.symbols + sym_idx;
+			if entry^.name.length > 0u & entry^.symbol_info <> nil then
+				if entry^.symbol_info^.kind = ElnaSymbolInfoKind.temporary_info then
+					temp_info := cast(entry^.symbol_info: ^ElnaSymbolTemporaryInfo);
+					if var_needs_stack_alloc(@proc_node^.body, proc_node^.symbol_table, entry^.name) then
+						alloc_size := 8u;
+						if temp_info^.variable_type <> nil & temp_info^.variable_type^.size > 8u then
+							alloc_size := (temp_info^.variable_type^.size + 7u) / 8u * 8u
+						end;
+						qbe_write_str(file, "\t%\0".ptr);
+						qbe_write_slice(file, entry^.name);
+						qbe_write_str(file, " =l alloc8 \0".ptr);
+						qbe_write_word(file, alloc_size);
+						qbe_write_str(file, "\n\0".ptr)
+					end
+				end
+			end;
+			sym_idx := sym_idx + 1u
+		end
+	end;
+
+	(* Emit TAC instructions *)
+	node := proc_node^.body.first;
+	while node <> nil do
+		inst := cast(node: ^ElnaTacInstruction);
+		last_operator := inst^.operator;
+
+		case inst^.operator of
+			ElnaTacOperator.get_address:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[2].name);
+				qbe_write_str(file, " =l copy \0".ptr);
+				if is_global(globals, inst^.operands[1].name) or is_string_constant(strings, inst^.operands[1].name) then
+					qbe_write_str(file, "$\0".ptr)
+				else
+					qbe_write_str(file, "%\0".ptr)
+				end;
+				qbe_write_slice(file, inst^.operands[1].name);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.copy:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[2].name);
+				qbe_write_str(file, " =l copy \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.add:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[3].name);
+				qbe_write_str(file, " =l add \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.subtract:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[3].name);
+				qbe_write_str(file, " =l sub \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.multiply:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[3].name);
+				qbe_write_str(file, " =l mul \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.divide:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[3].name);
+				qbe_write_str(file, " =l div \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.remainder:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[3].name);
+				qbe_write_str(file, " =l rem \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator._or:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[3].name);
+				qbe_write_str(file, " =l or \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator._xor:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[3].name);
+				qbe_write_str(file, " =l xor \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.and:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[3].name);
+				qbe_write_str(file, " =l and \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.equal:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[3].name);
+				qbe_write_str(file, " =w ceql \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.not_equal:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[3].name);
+				qbe_write_str(file, " =w cnew \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.less_than:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[3].name);
+				qbe_write_str(file, " =w csltl \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.greater_than:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[3].name);
+				qbe_write_str(file, " =w csgtl \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.less_or_equal:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[3].name);
+				qbe_write_str(file, " =w cslel \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.greater_or_equal:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[3].name);
+				qbe_write_str(file, " =w csgel \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.negate:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[2].name);
+				qbe_write_str(file, " =l neg \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.complement:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[2].name);
+				qbe_write_str(file, " =l xor \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", -1\n\0".ptr)
+			| ElnaTacOperator.load:
+				qbe_write_str(file, "\t%\0".ptr);
+				qbe_write_slice(file, inst^.operands[2].name);
+				qbe_write_str(file, " =l loadl \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.store:
+				qbe_write_str(file, "\tstorel \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.copy_to_offset:
+				if inst^.operands[3].constant = 0u then
+					qbe_write_str(file, "\tstorel \0".ptr);
+					qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+					qbe_write_str(file, ", \0".ptr);
+					qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+					qbe_write_str(file, "\n\0".ptr)
+				else
+					qbe_unique_id := qbe_unique_id + 1u;
+					tid := qbe_unique_id;
+					qbe_write_str(file, "\t%qbe_off_\0".ptr);
+					qbe_write_word(file, tid);
+					qbe_write_str(file, " =l add \0".ptr);
+					qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+					qbe_write_str(file, ", \0".ptr);
+					qbe_write_word(file, inst^.operands[3].constant);
+					qbe_write_str(file, "\n\tstorel \0".ptr);
+					qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+					qbe_write_str(file, ", %qbe_off_\0".ptr);
+					qbe_write_word(file, tid);
+					qbe_write_str(file, "\n\0".ptr)
+				end
+			| ElnaTacOperator.copy_from_offset:
+				if inst^.operands[2].constant = 0u then
+					qbe_write_str(file, "\t%\0".ptr);
+					qbe_write_slice(file, inst^.operands[3].name);
+					qbe_write_str(file, " =l loadl \0".ptr);
+					qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+					qbe_write_str(file, "\n\0".ptr)
+				else
+					qbe_unique_id := qbe_unique_id + 1u;
+					tid := qbe_unique_id;
+					qbe_write_str(file, "\t%qbe_off_\0".ptr);
+					qbe_write_word(file, tid);
+					qbe_write_str(file, " =l add \0".ptr);
+					qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+					qbe_write_str(file, ", \0".ptr);
+					qbe_write_word(file, inst^.operands[2].constant);
+					qbe_write_str(file, "\n\t%\0".ptr);
+					qbe_write_slice(file, inst^.operands[3].name);
+					qbe_write_str(file, " =l loadl %qbe_off_\0".ptr);
+					qbe_write_word(file, tid);
+					qbe_write_str(file, "\n\0".ptr)
+				end
+			| ElnaTacOperator.add_ptr:
+				qbe_unique_id := qbe_unique_id + 1u;
+				tid := qbe_unique_id;
+				if inst^.operands[2].kind = ElnaTacKind.constant then
+					if inst^.operands[3].constant = 1u then
+						qbe_write_str(file, "\t%\0".ptr);
+						qbe_write_slice(file, inst^.operands[4].name);
+						qbe_write_str(file, " =l add \0".ptr);
+						qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+						qbe_write_str(file, ", \0".ptr);
+						qbe_write_word(file, inst^.operands[2].constant);
+						qbe_write_str(file, "\n\0".ptr)
+					else
+						scaled := inst^.operands[2].constant * inst^.operands[3].constant;
+						qbe_write_str(file, "\t%\0".ptr);
+						qbe_write_slice(file, inst^.operands[4].name);
+						qbe_write_str(file, " =l add \0".ptr);
+						qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+						qbe_write_str(file, ", \0".ptr);
+						qbe_write_word(file, scaled);
+						qbe_write_str(file, "\n\0".ptr)
+					end
+				else
+					qbe_write_str(file, "\t%qbe_ext_\0".ptr);
+					qbe_write_word(file, tid);
+					qbe_write_str(file, " =l extuw \0".ptr);
+					qbe_emit_operand(file, @inst^.operands[2], globals, strings);
+					qbe_write_str(file, "\n\0".ptr);
+
+					if inst^.operands[3].constant = 1u then
+						qbe_write_str(file, "\t%\0".ptr);
+						qbe_write_slice(file, inst^.operands[4].name);
+						qbe_write_str(file, " =l add \0".ptr);
+						qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+						qbe_write_str(file, ", %qbe_ext_\0".ptr);
+						qbe_write_word(file, tid);
+						qbe_write_str(file, "\n\0".ptr)
+					else
+						qbe_write_str(file, "\t%qbe_s_\0".ptr);
+						qbe_write_word(file, tid);
+						qbe_write_str(file, " =l mul %qbe_ext_\0".ptr);
+						qbe_write_word(file, tid);
+						qbe_write_str(file, ", \0".ptr);
+						qbe_write_word(file, inst^.operands[3].constant);
+						qbe_write_str(file, "\n\t%\0".ptr);
+						qbe_write_slice(file, inst^.operands[4].name);
+						qbe_write_str(file, " =l add \0".ptr);
+						qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+						qbe_write_str(file, ", %qbe_s_\0".ptr);
+						qbe_write_word(file, tid);
+						qbe_write_str(file, "\n\0".ptr)
+					end
+				end
+			| ElnaTacOperator.proc_call:
+				callee_ret := get_procedure_return_type(inst^.operands[1].name);
+				if inst^.operands[3].kind = ElnaTacKind.ignore then
+					qbe_write_str(file, "\tcall $\0".ptr)
+				else
+					qbe_write_str(file, "\t%\0".ptr);
+					qbe_write_slice(file, inst^.operands[3].name);
+					if callee_ret = bool_type then
+						qbe_write_str(file, " =w call $\0".ptr)
+					else
+						qbe_write_str(file, " =l call $\0".ptr)
+					end
+				end;
+				qbe_write_slice(file, inst^.operands[1].name);
+				qbe_write_str(file, "(\0".ptr);
+
+				arg_i := 0u;
+				while arg_i < inst^.operands[2].length do
+					arg_op := inst^.operands[2].list_operands + arg_i;
+					qbe_write_str(file, "l \0".ptr);
+					qbe_emit_operand(file, arg_op, globals, strings);
+					if arg_i + 1u < inst^.operands[2].length then
+						qbe_write_str(file, ", \0".ptr)
+					end;
+					arg_i := arg_i + 1u
+				end;
+				qbe_write_str(file, ")\n\0".ptr)
+			| ElnaTacOperator.jump:
+				qbe_write_str(file, "\tjmp @\0".ptr);
+				qbe_write_slice(file, inst^.operands[1].name);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.jump_if_zero:
+				qbe_unique_id := qbe_unique_id + 1u;
+				tid := qbe_unique_id;
+				qbe_write_str(file, "\tjnz \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", @qbe_ft_\0".ptr);
+				qbe_write_word(file, tid);
+				qbe_write_str(file, ", @\0".ptr);
+				qbe_write_slice(file, inst^.operands[2].name);
+				qbe_write_str(file, "\n@qbe_ft_\0".ptr);
+				qbe_write_word(file, tid);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.jump_if_not_zero:
+				qbe_unique_id := qbe_unique_id + 1u;
+				tid := qbe_unique_id;
+				qbe_write_str(file, "\tjnz \0".ptr);
+				qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+				qbe_write_str(file, ", @\0".ptr);
+				qbe_write_slice(file, inst^.operands[2].name);
+				qbe_write_str(file, ", @qbe_ft_\0".ptr);
+				qbe_write_word(file, tid);
+				qbe_write_str(file, "\n@qbe_ft_\0".ptr);
+				qbe_write_word(file, tid);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator.label:
+				qbe_write_str(file, "@\0".ptr);
+				qbe_write_slice(file, inst^.operands[1].name);
+				qbe_write_str(file, "\n\0".ptr)
+			| ElnaTacOperator._return:
+				if inst^.operands[1].kind = ElnaTacKind.ignore then
+					qbe_write_str(file, "\tret\n\0".ptr)
+				else
+					qbe_write_str(file, "\tret \0".ptr);
+					qbe_emit_operand(file, @inst^.operands[1], globals, strings);
+					qbe_write_str(file, "\n\0".ptr)
+				end
+			else
+		end;
+		node := node^.next
+	end;
+
+	(* Function terminator if not terminated *)
+	if last_operator <> ElnaTacOperator._return & last_operator <> ElnaTacOperator.jump then
+		if proc_node^.name = "main" then
+			qbe_write_str(file, "\tret 0\n\0".ptr)
+		elsif ret_type = nil then
+			qbe_write_str(file, "\tret\n\0".ptr)
+		else
+			qbe_write_str(file, "\tret 0\n\0".ptr)
+		end
+	end;
+
+	qbe_write_str(file, "}\n\n\0".ptr)
+return
+
+proc elna_qbe_emit*(instruction_module: ^ElnaInstructionModule; out_file: ^FILE)
+var
+	current_string: ^ElnaTacStringConstant
+	current_global: ^ElnaTacStaticVariable
+	current_proc: ^ElnaTacProcedure
+	i: Word
+	byte_val: Word
+begin
+	(* Emit strings *)
+	current_string := instruction_module^.strings;
+	while current_string <> nil do
+		qbe_write_str(out_file, "data $\0".ptr);
+		qbe_write_slice(out_file, current_string^.name);
+		qbe_write_str(out_file, " = { \0".ptr);
+
+		i := 0u;
+		while i < current_string^.value.length do
+			qbe_write_str(out_file, "b \0".ptr);
+			byte_val := cast((current_string^.value.ptr + i)^: Word);
+			qbe_write_word(out_file, byte_val);
+			qbe_write_str(out_file, ", \0".ptr);
+			i := i + 1u
+		end;
+		qbe_write_str(out_file, "b 0 }\n\0".ptr);
+
+		current_string := current_string^.next
+	end;
+
+	(* Emit global data *)
+	current_global := instruction_module^.data;
+	while current_global <> nil do
+		qbe_write_str(out_file, "export data $\0".ptr);
+		qbe_write_slice(out_file, current_global^.name);
+		qbe_write_str(out_file, " = { z \0".ptr);
+		qbe_write_word(out_file, current_global^.size);
+		qbe_write_str(out_file, " }\n\0".ptr);
+
+		current_global := current_global^.next
+	end;
+
+	(* Emit procedures *)
+	current_proc := instruction_module^.code;
+	while current_proc <> nil do
+		qbe_emit_procedure(out_file, current_proc, instruction_module^.data, instruction_module^.strings);
+		current_proc := current_proc^.next
+	end
+return
+
+end.
diff --git a/source/symbol.elna b/source/symbol.elna
new file mode 100644
index 0000000..531f58c
--- /dev/null
+++ b/source/symbol.elna
@@ -0,0 +1,200 @@
+(* 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/. *)
+module
+import cstdlib, common, ast
+
+type
+	ElnaSymbolInfoKind* = (type_info, temporary_info, procedure_info)
+	ElnaSymbolInfo* = record
+		kind: ElnaSymbolInfoKind
+	end
+	ElnaSymbolTypeInfo* = record(ElnaSymbolInfo)
+		_type: ^ElnaType
+	end
+	ElnaSymbolTemporaryInfo* = record(ElnaSymbolInfo)
+		attr: Word;
+		variable_type: ^ElnaType
+	end
+	ElnaSymbolProcedureInfo* = record(ElnaSymbolInfo)
+		symbol_table: ^ElnaSymbolTable;
+		procedure_type: ^ElnaTypeProcedure;
+		is_extern: Bool
+	end
+
+	ElnaSymbolEntry* = record
+		name: []const Word8;
+		symbol_info: ^ElnaSymbolInfo
+	end
+	ElnaSymbolTable* = record
+		count: Word;
+		capacity: Word;
+		parent: ^ElnaSymbolTable;
+		symbols: ^ElnaSymbolEntry
+	end
+
+var
+	symbol_table_global*: ^ElnaSymbolTable
+	word_type*: ^ElnaType
+	int_type*: ^ElnaType
+	pointer_type*: ^ElnaType
+	bool_type*: ^ElnaType
+	char_type*: ^ElnaType
+	string_type*: ^ElnaTypeRecord
+
+proc elna_symbol_type_info_create*(type_representation: ^ElnaType) -> ^ElnaSymbolTypeInfo
+var
+	result: ^ElnaSymbolTypeInfo
+begin
+	result := malloc#[ElnaSymbolTypeInfo](#size(ElnaSymbolTypeInfo));
+	result^.kind := ElnaSymbolInfoKind.type_info;
+	result^._type := type_representation
+return result
+
+proc elna_symbol_temporary_info_create*(attr: Word; temporary_type: ^ElnaType) -> ^ElnaSymbolTemporaryInfo
+var
+	result: ^ElnaSymbolTemporaryInfo
+begin
+	result := malloc#[ElnaSymbolTemporaryInfo](#size(ElnaSymbolTemporaryInfo));
+	result^.kind := ElnaSymbolInfoKind.temporary_info;
+	result^.variable_type := temporary_type;
+	result^.attr := attr
+return result
+
+proc elna_symbol_procedure_info_create*(is_extern: Bool) -> ^ElnaSymbolProcedureInfo
+var
+	result: ^ElnaSymbolProcedureInfo
+begin
+	result := malloc#[ElnaSymbolProcedureInfo](#size(ElnaSymbolProcedureInfo));
+	result^.kind := ElnaSymbolInfoKind.procedure_info;
+	result^.procedure_type := nil;
+	result^.symbol_table := nil;
+	result^.is_extern := is_extern
+return result
+
+proc elna_symbol_table_create*(parent: ^ElnaSymbolTable) -> ^ElnaSymbolTable
+var
+	new_symbol_table: ^ElnaSymbolTable
+begin
+	new_symbol_table := malloc#[ElnaSymbolTable](#size(ElnaSymbolTable));
+	new_symbol_table^.capacity := 64u;
+	new_symbol_table^.symbols := malloc#[ElnaSymbolEntry](new_symbol_table^.capacity * #size(ElnaSymbolEntry));
+	new_symbol_table^.count := 0u;
+	new_symbol_table^.parent := parent
+return new_symbol_table
+
+proc elna_symbol_table_enter*(symbol_table: ^ElnaSymbolTable; symbol_name: []const Word8; symbol: ^ElnaSymbolInfo)
+var
+	entry: ^ElnaSymbolEntry
+begin
+	if symbol_table^.count >= symbol_table^.capacity then
+		symbol_table^.capacity := symbol_table^.capacity * 2u;
+		symbol_table^.symbols := realloc#[ElnaSymbolEntry](symbol_table^.symbols, symbol_table^.capacity * #size(ElnaSymbolEntry))
+	end;
+	entry := symbol_table^.symbols + symbol_table^.count;
+	entry^.name := symbol_name;
+	entry^.symbol_info := symbol;
+	symbol_table^.count := symbol_table^.count + 1u
+return
+
+proc elna_symbol_table_lookup_local*(symbol_table: ^ElnaSymbolTable; symbol_name: []const Word8) -> ^ElnaSymbolInfo
+var
+	i: Word := 0u
+	entry: ^ElnaSymbolEntry
+	result: ^ElnaSymbolInfo := nil
+begin
+	while i < symbol_table^.count & result = nil do
+		entry := symbol_table^.symbols + i;
+		if entry^.name = symbol_name then
+			result := entry^.symbol_info
+		end;
+		i := i + 1u
+	end
+return result
+
+proc elna_symbol_table_lookup*(symbol_table: ^ElnaSymbolTable; symbol_name: []const Word8) -> ^ElnaSymbolInfo
+var
+	current: ^ElnaSymbolTable
+	found: ^ElnaSymbolInfo := nil
+begin
+	current := symbol_table;
+	while current <> nil & found = nil do
+		found := elna_symbol_table_lookup_local(current, symbol_name);
+		current := current^.parent
+	end
+return found
+
+proc elna_symbol_string_build()
+var
+	current_field: ^ElnaTypeField
+	char_pointer: ^ElnaTypePointer
+begin
+	string_type := malloc#[ElnaTypeRecord](#size(ElnaTypeRecord));
+	string_type^.kind := ElnaTypeKind._record;
+	string_type^.size := 16u;
+	string_type^.alignment := 8u;
+	string_type^.members := malloc#[ElnaTypeField](2u * #size(ElnaTypeField));
+	string_type^.length := 2u;
+
+	char_pointer := malloc#[ElnaTypePointer](#size(ElnaTypePointer));
+	char_pointer^.kind := ElnaTypeKind.pointer;
+	char_pointer^.size := 8u;
+	char_pointer^.alignment := 8u;
+	char_pointer^.base := char_type;
+
+	current_field := string_type^.members;
+	current_field^.name := "ptr";
+	current_field^.field_type := cast(char_pointer: ^ElnaType);
+
+	current_field := current_field + 1u;
+	current_field^.name := "length";
+	current_field^.field_type := word_type
+return
+
+proc elna_symbol_table_build*()
+var
+	current_info: ^ElnaSymbolTypeInfo
+begin
+	symbol_table_global := elna_symbol_table_create(nil);
+
+	word_type := malloc#[ElnaType](#size(ElnaType));
+	word_type^.kind := ElnaTypeKind.primitive;
+	word_type^.size := 8u;
+	word_type^.alignment := 8u;
+	current_info := elna_symbol_type_info_create(word_type);
+	elna_symbol_table_enter(symbol_table_global, "Word", cast(current_info: ^ElnaSymbolInfo));
+
+	int_type := malloc#[ElnaType](#size(ElnaType));
+	int_type^.kind := ElnaTypeKind.primitive;
+	int_type^.size := 8u;
+	int_type^.alignment := 8u;
+	current_info := elna_symbol_type_info_create(int_type);
+	elna_symbol_table_enter(symbol_table_global, "Int", cast(current_info: ^ElnaSymbolInfo));
+
+	pointer_type := malloc#[ElnaType](#size(ElnaType));
+	pointer_type^.kind := ElnaTypeKind.primitive;
+	pointer_type^.size := 8u;
+	pointer_type^.alignment := 8u;
+	current_info := elna_symbol_type_info_create(pointer_type);
+	elna_symbol_table_enter(symbol_table_global, "Pointer", cast(current_info: ^ElnaSymbolInfo));
+
+	bool_type := malloc#[ElnaType](#size(ElnaType));
+	bool_type^.kind := ElnaTypeKind.primitive;
+	bool_type^.size := 1u;
+	bool_type^.alignment := 1u;
+	current_info := elna_symbol_type_info_create(bool_type);
+	elna_symbol_table_enter(symbol_table_global, "Bool", cast(current_info: ^ElnaSymbolInfo));
+
+	char_type := malloc#[ElnaType](#size(ElnaType));
+	char_type^.kind := ElnaTypeKind.primitive;
+	char_type^.size := 1u;
+	char_type^.alignment := 1u;
+	current_info := elna_symbol_type_info_create(char_type);
+	elna_symbol_table_enter(symbol_table_global, "Char", cast(current_info: ^ElnaSymbolInfo));
+
+	elna_symbol_string_build();
+	current_info := elna_symbol_type_info_create(cast(string_type: ^ElnaType));
+	elna_symbol_table_enter(symbol_table_global, "String", cast(current_info: ^ElnaSymbolInfo))
+return
+
+end.
diff --git a/source/tac.elna b/source/tac.elna
new file mode 100644
index 0000000..7b05ab2
--- /dev/null
+++ b/source/tac.elna
@@ -0,0 +1,1074 @@
+(* 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/. *)
+module
+import common, cstdlib, cstdio, cstring, lexer, ast, symbol, diagnostic
+
+type
+	ElnaTacOperator* = (
+		get_address,
+		add,
+		load,
+		store,
+		proc_call,
+		copy,
+		copy_to_offset,
+		copy_from_offset,
+		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,
+		add_ptr,
+		nop
+	)
+
+	ElnaTacKind* = (list, label, constant, variable, ignore)
+
+	ElnaTacOperand* = record
+		kind: ElnaTacKind;
+		name: []const Word8;
+		constant: Word;
+		length: Word;
+		list_operands: ^ElnaTacOperand
+	end
+
+	ElnaTacInstruction* = record(ElnaListNode)
+		operator: ElnaTacOperator;
+		operands: [4]ElnaTacOperand
+	end
+
+	ElnaTacProcedure* = record
+		next: ^ElnaTacProcedure;
+		name: []const Word8;
+		body: ElnaList;
+		parameters: ^[]const Word8;
+		count: Word;
+		symbol_table: ^ElnaSymbolTable
+	end
+
+	ElnaTacStaticVariable* = record
+		next: ^ElnaTacStaticVariable;
+		name: []const Word8;
+		size: Word
+	end
+
+	ElnaTacStringConstant* = record
+		next: ^ElnaTacStringConstant;
+		name: []const Word8;
+		value: []const Word8
+	end
+
+	ElnaInstructionModule* = record
+		strings: ^ElnaTacStringConstant;
+		data: ^ElnaTacStaticVariable;
+		code: ^ElnaTacProcedure
+	end
+
+	ElnaTacOperandType = (plain_object, dereferenced_pointer, sub_object)
+
+	ElnaTacOperandResult = record
+		kind: ElnaTacOperandType;
+		offset: Word
+	end
+
+var
+	pseudo_counter: Word := 0u
+	label_counter: Word := 0u
+	string_counter: Word := 0u
+	module_strings_first: ^ElnaTacStringConstant := nil
+	module_strings_last: ^ElnaTacStringConstant := nil
+
+proc elna_tac_instruction_create*(operator: ElnaTacOperator) -> ^ElnaTacInstruction
+var
+	result: ^ElnaTacInstruction
+begin
+	result := malloc#[ElnaTacInstruction](#size(ElnaTacInstruction));
+	result^.next := nil;
+	result^.operator := operator;
+	result^.operands[1].kind := ElnaTacKind.ignore;
+	result^.operands[2].kind := ElnaTacKind.ignore;
+	result^.operands[3].kind := ElnaTacKind.ignore;
+	result^.operands[4].kind := ElnaTacKind.ignore
+return result
+
+proc elna_tac_instruction_set_operand*(this: ^ElnaTacInstruction; n: Word;
+		kind: ElnaTacKind; name: []const Word8; constant: Word; length: Word)
+begin
+	this^.operands[n].kind := kind;
+	this^.operands[n].name := name;
+	this^.operands[n].constant := constant;
+	this^.operands[n].length := length;
+	this^.operands[n].list_operands := nil
+return
+
+proc elna_tac_instruction_set_op*(this: ^ElnaTacInstruction; n: Word; op: ^ElnaTacOperand)
+begin
+	this^.operands[n] := op^
+return
+
+proc elna_tac_instruction_set_const*(this: ^ElnaTacInstruction; n: Word; value: Word; length: Word)
+begin
+	this^.operands[n].kind := ElnaTacKind.constant;
+	this^.operands[n].name := "";
+	this^.operands[n].constant := value;
+	this^.operands[n].length := length;
+	this^.operands[n].list_operands := nil
+return
+
+proc elna_tac_instruction_set_label*(this: ^ElnaTacInstruction; n: Word; label_name: []const Word8)
+begin
+	this^.operands[n].kind := ElnaTacKind.label;
+	this^.operands[n].name := label_name;
+	this^.operands[n].constant := 0u;
+	this^.operands[n].length := label_name.length;
+	this^.operands[n].list_operands := nil
+return
+
+proc elna_tac_make_variable*(operand: ^ElnaTacOperand; symbol_table: ^ElnaSymbolTable; variable_type: ^ElnaType)
+var
+	buffer: ^Word8
+	name_slice: []const Word8
+	temporary_info: ^ElnaSymbolTemporaryInfo
+	len: Int
+begin
+	pseudo_counter := pseudo_counter + 1u;
+	buffer := malloc#[Word8](16u);
+	len := sprintf(buffer, "t%u\0".ptr, pseudo_counter);
+
+	name_slice := buffer[1u to cast(len: Word)];
+
+	operand^.kind := ElnaTacKind.variable;
+	operand^.name := name_slice;
+	operand^.constant := 0u;
+	operand^.length := name_slice.length;
+	operand^.list_operands := nil;
+
+	temporary_info := elna_symbol_temporary_info_create(1u, variable_type);
+	elna_symbol_table_enter(symbol_table, name_slice, cast(temporary_info: ^ElnaSymbolInfo))
+return
+
+proc elna_tac_label*() -> []const Word8
+var
+	buffer: ^Word8
+	result: []const Word8
+	len: Int
+begin
+	label_counter := label_counter + 1u;
+	buffer := malloc#[Word8](16u);
+	len := sprintf(buffer, "l%u\0".ptr, label_counter);
+	result := buffer[1u to cast(len: Word)]
+return result
+
+proc elna_tac_integer_literal(integer_literal_node: ^ElnaTreeIntegerLiteral; operand: ^ElnaTacOperand)
+begin
+	operand^.kind := ElnaTacKind.constant;
+	operand^.name := "";
+	operand^.constant := integer_literal_node^.value;
+	operand^.length := word_type^.size;
+	operand^.list_operands := nil
+return
+
+proc elna_tac_boolean_literal(boolean_literal_node: ^ElnaTreeBooleanLiteral; operand: ^ElnaTacOperand)
+begin
+	operand^.kind := ElnaTacKind.constant;
+	operand^.name := "";
+	if boolean_literal_node^.value then
+		operand^.constant := 1u
+	else
+		operand^.constant := 0u
+	end;
+	operand^.length := bool_type^.size;
+	operand^.list_operands := nil
+return
+
+proc elna_tac_nil_literal(operand: ^ElnaTacOperand)
+begin
+	operand^.kind := ElnaTacKind.constant;
+	operand^.name := "";
+	operand^.constant := 0u;
+	operand^.length := 8u;
+	operand^.list_operands := nil
+return
+
+proc elna_tac_character_literal(character_literal_node: ^ElnaTreeCharacterLiteral; operand: ^ElnaTacOperand)
+begin
+	operand^.kind := ElnaTacKind.constant;
+	operand^.name := "";
+	operand^.constant := cast(character_literal_node^.value: Word);
+	operand^.length := char_type^.size;
+	operand^.list_operands := nil
+return
+
+proc elna_tac_variable_expression(variable_expression: ^ElnaTreeVariableExpression; operand: ^ElnaTacOperand)
+begin
+	operand^.kind := ElnaTacKind.variable;
+	operand^.name := variable_expression^.name;
+	operand^.constant := 0u;
+	operand^.length := variable_expression^.name.length;
+	operand^.list_operands := nil
+return
+
+proc elna_tac_trait_expression(trait_node: ^ElnaTreeTraitExpression; operand: ^ElnaTacOperand)
+var
+	symbol_info: ^ElnaSymbolInfo
+	type_info: ^ElnaSymbolTypeInfo
+	parser_node: ^ElnaTreeNamedTypeExpression
+begin
+	parser_node := cast(trait_node^.argument: ^ElnaTreeNamedTypeExpression);
+	symbol_info := elna_symbol_table_lookup(symbol_table_global, parser_node^.name);
+
+	operand^.kind := ElnaTacKind.constant;
+	operand^.name := "";
+	operand^.length := 8u;
+	operand^.list_operands := nil;
+	if symbol_info <> nil & symbol_info^.kind = ElnaSymbolInfoKind.type_info then
+		type_info := cast(symbol_info: ^ElnaSymbolTypeInfo);
+		operand^.constant := type_info^._type^.size
+	else
+		operand^.constant := 0u
+	end
+return
+
+proc elna_tac_string_literal(instructions: ^ElnaList; string_literal_node: ^ElnaTreeStringLiteral;
+		symbol_table: ^ElnaSymbolTable; operand: ^ElnaTacOperand)
+var
+	string_entry: ^ElnaTacStringConstant
+	label_buf: ^Word8
+	label_slice: []const Word8
+	label_len: Int
+	instruction: ^ElnaTacInstruction
+	address: ElnaTacOperand
+begin
+	string_counter := string_counter + 1u;
+	label_buf := malloc#[Word8](16u);
+	label_len := sprintf(label_buf, "str_%u\0".ptr, string_counter);
+	label_slice := label_buf[1u to cast(label_len: Word)];
+
+	string_entry := malloc#[ElnaTacStringConstant](#size(ElnaTacStringConstant));
+	string_entry^.next := nil;
+	string_entry^.name := label_slice;
+	string_entry^.value := string_literal_node^.value;
+
+	if module_strings_first = nil then
+		module_strings_first := string_entry
+	else
+		module_strings_last^.next := string_entry
+	end;
+	module_strings_last := string_entry;
+
+	elna_tac_make_variable(operand, symbol_table, cast(string_type: ^ElnaType));
+	elna_tac_make_variable(@address, symbol_table, pointer_type);
+
+	instruction := elna_tac_instruction_create(ElnaTacOperator.get_address);
+	elna_tac_instruction_set_operand(instruction, 1u, ElnaTacKind.variable, label_slice, 0u, label_slice.length);
+	elna_tac_instruction_set_op(instruction, 2u, @address);
+	elna_list_append(instructions, cast(instruction: ^ElnaListNode));
+
+	instruction := elna_tac_instruction_create(ElnaTacOperator.copy_to_offset);
+	elna_tac_instruction_set_op(instruction, 1u, @address);
+	elna_tac_instruction_set_op(instruction, 2u, operand);
+	elna_tac_instruction_set_const(instruction, 3u, 0u, 8u);
+	elna_list_append(instructions, cast(instruction: ^ElnaListNode));
+
+	instruction := elna_tac_instruction_create(ElnaTacOperator.copy_to_offset);
+	elna_tac_instruction_set_const(instruction, 1u, string_literal_node^.value.length, 8u);
+	elna_tac_instruction_set_op(instruction, 2u, operand);
+	elna_tac_instruction_set_const(instruction, 3u, 8u, 8u);
+	elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+return
+
+proc elna_tac_copy_address(instructions: ^ElnaList; operand_result: ^ElnaTacOperandResult; from, dest: ^ElnaTacOperand)
+var
+	instruction: ^ElnaTacInstruction
+begin
+	if operand_result^.kind = ElnaTacOperandType.dereferenced_pointer then
+		dest^ := from^
+	elsif operand_result^.kind = ElnaTacOperandType.sub_object then
+		instruction := elna_tac_instruction_create(ElnaTacOperator.get_address);
+		elna_tac_instruction_set_op(instruction, 1u, from);
+		elna_tac_instruction_set_op(instruction, 2u, dest);
+		elna_list_append(instructions, cast(instruction: ^ElnaListNode));
+
+		instruction := elna_tac_instruction_create(ElnaTacOperator.add);
+		elna_tac_instruction_set_const(instruction, 1u, operand_result^.offset, 4u);
+		elna_tac_instruction_set_op(instruction, 2u, dest);
+		elna_tac_instruction_set_op(instruction, 3u, dest);
+		elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+	else
+		instruction := elna_tac_instruction_create(ElnaTacOperator.get_address);
+		elna_tac_instruction_set_op(instruction, 1u, from);
+		elna_tac_instruction_set_op(instruction, 2u, dest);
+		elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+	end
+return
+
+proc elna_tac_simple_expression(instructions: ^ElnaList; parser_node: ^ElnaTreeExpression;
+		symbol_table: ^ElnaSymbolTable; operand: ^ElnaTacOperand)
+begin
+	case parser_node^.kind of
+		ElnaTreeKind.integer_literal:
+			elna_tac_integer_literal(cast(parser_node: ^ElnaTreeIntegerLiteral), operand)
+		| ElnaTreeKind.character_literal:
+			elna_tac_character_literal(cast(parser_node: ^ElnaTreeCharacterLiteral), operand)
+		| ElnaTreeKind.string_literal:
+			elna_tac_string_literal(instructions, cast(parser_node: ^ElnaTreeStringLiteral), symbol_table, operand)
+		| ElnaTreeKind.boolean_literal:
+			elna_tac_boolean_literal(cast(parser_node: ^ElnaTreeBooleanLiteral), operand)
+		| ElnaTreeKind.null:
+			elna_tac_nil_literal(operand)
+		| ElnaTreeKind.variable_expression:
+			elna_tac_variable_expression(cast(parser_node: ^ElnaTreeVariableExpression), operand)
+		| ElnaTreeKind.trait_expression:
+			elna_tac_trait_expression(cast(parser_node: ^ElnaTreeTraitExpression), operand)
+		| ElnaTreeKind._cast:
+			elna_tac_binary_expression(instructions, (cast(parser_node: ^ElnaTreeCastExpression))^.expression, symbol_table, operand)
+		else
+	end
+return
+
+proc elna_tac_unary_expression(instructions: ^ElnaList; parser_node: ^ElnaTreeExpression;
+		symbol_table: ^ElnaSymbolTable; operand: ^ElnaTacOperand)
+var
+	operator: ElnaLexerKind
+	unary_operand: ^ElnaTreeExpression
+	unary_node: ^ElnaTreeUnaryExpression
+	operand_result: ElnaTacOperandResult
+	instruction: ^ElnaTacInstruction
+	base: ElnaTacOperand
+	has_unary: Bool := false
+begin
+	if parser_node^.kind = ElnaTreeKind.unary_expression then
+		unary_node := cast(parser_node: ^ElnaTreeUnaryExpression);
+		operator := unary_node^.operator;
+		unary_operand := unary_node^.operand;
+		has_unary := true
+	else
+		unary_operand := parser_node
+	end;
+	elna_tac_designator(instructions, unary_operand, symbol_table, @operand_result, @base);
+
+	if has_unary & operator = ElnaLexerKind.at then
+		elna_tac_make_variable(operand, symbol_table, word_type);
+		elna_tac_copy_address(instructions, @operand_result, @base, operand)
+	elsif has_unary & operator = ElnaLexerKind.minus then
+		elna_tac_make_variable(operand, symbol_table, parser_node^.type_decoration);
+		instruction := elna_tac_instruction_create(ElnaTacOperator.negate);
+		elna_tac_instruction_set_op(instruction, 1u, @base);
+		elna_tac_instruction_set_op(instruction, 2u, operand);
+		elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+	elsif has_unary & operator = ElnaLexerKind.not then
+		elna_tac_make_variable(operand, symbol_table, parser_node^.type_decoration);
+		instruction := elna_tac_instruction_create(ElnaTacOperator.complement);
+		elna_tac_instruction_set_op(instruction, 1u, @base);
+		elna_tac_instruction_set_op(instruction, 2u, operand);
+		elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+	elsif operand_result.kind = ElnaTacOperandType.dereferenced_pointer then
+		elna_tac_make_variable(operand, symbol_table, parser_node^.type_decoration);
+		instruction := elna_tac_instruction_create(ElnaTacOperator.load);
+		elna_tac_instruction_set_op(instruction, 1u, @base);
+		elna_tac_instruction_set_op(instruction, 2u, operand);
+		elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+	elsif operand_result.kind = ElnaTacOperandType.sub_object then
+		elna_tac_make_variable(operand, symbol_table, parser_node^.type_decoration);
+		instruction := elna_tac_instruction_create(ElnaTacOperator.copy_from_offset);
+		elna_tac_instruction_set_op(instruction, 1u, @base);
+		elna_tac_instruction_set_const(instruction, 2u, operand_result.offset, 4u);
+		elna_tac_instruction_set_op(instruction, 3u, operand);
+		elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+	else
+		operand^ := base
+	end
+return
+
+proc elna_tac_add_pointer(parser_node: ^ElnaTreeExpression; lhs, rhs: ^ElnaTacOperand;
+		symbol_table: ^ElnaSymbolTable; operand: ^ElnaTacOperand) -> ^ElnaTacInstruction
+var
+	instruction: ^ElnaTacInstruction
+	pointer_type_node: ^ElnaTypePointer
+	elem_size: Word := 1u
+begin
+	if parser_node^.type_decoration <> nil & parser_node^.type_decoration^.kind = ElnaTypeKind.pointer then
+		pointer_type_node := cast(parser_node^.type_decoration: ^ElnaTypePointer);
+		if pointer_type_node^.base <> nil then
+			elem_size := pointer_type_node^.base^.size
+		end
+	end;
+	instruction := elna_tac_instruction_create(ElnaTacOperator.add_ptr);
+	elna_tac_make_variable(operand, symbol_table, word_type);
+	elna_tac_instruction_set_op(instruction, 1u, lhs);
+	elna_tac_instruction_set_op(instruction, 2u, rhs);
+	elna_tac_instruction_set_const(instruction, 3u, elem_size, 4u);
+	elna_tac_instruction_set_op(instruction, 4u, operand)
+return instruction
+
+proc elna_tac_binary_create(instructions: ^ElnaList; operator: ElnaTacOperator;
+		lhs, rhs: ^ElnaTacOperand; symbol_table: ^ElnaSymbolTable; operand: ^ElnaTacOperand)
+var
+	instruction: ^ElnaTacInstruction
+	lhs_symbol: ^ElnaSymbolInfo
+	temp_info: ^ElnaSymbolTemporaryInfo
+	variable_type: ^ElnaType := word_type
+begin
+	if lhs^.kind = ElnaTacKind.variable then
+		lhs_symbol := elna_symbol_table_lookup(symbol_table, lhs^.name);
+		if lhs_symbol <> nil & lhs_symbol^.kind = ElnaSymbolInfoKind.temporary_info then
+			temp_info := cast(lhs_symbol: ^ElnaSymbolTemporaryInfo);
+			variable_type := temp_info^.variable_type
+		end
+	end;
+	elna_tac_make_variable(operand, symbol_table, variable_type);
+
+	instruction := elna_tac_instruction_create(operator);
+	elna_tac_instruction_set_op(instruction, 1u, lhs);
+	elna_tac_instruction_set_op(instruction, 2u, rhs);
+	elna_tac_instruction_set_op(instruction, 3u, operand);
+	elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+return
+
+proc elna_tac_subtract_create(instructions: ^ElnaList; parser_node: ^ElnaTreeBinaryExpression;
+		lhs, rhs: ^ElnaTacOperand; symbol_table: ^ElnaSymbolTable; operand: ^ElnaTacOperand)
+var
+	instruction: ^ElnaTacInstruction
+	lhs_is_pointer: Bool := false
+	rhs_is_not_pointer: Bool := true
+begin
+	if parser_node^.lhs^.type_decoration <> nil & parser_node^.lhs^.type_decoration^.kind = ElnaTypeKind.pointer then
+		lhs_is_pointer := true
+	end;
+	if parser_node^.rhs^.type_decoration <> nil & parser_node^.rhs^.type_decoration^.kind = ElnaTypeKind.pointer then
+		rhs_is_not_pointer := false
+	end;
+
+	if lhs_is_pointer & rhs_is_not_pointer then
+		instruction := elna_tac_instruction_create(ElnaTacOperator.negate);
+		elna_tac_instruction_set_op(instruction, 1u, rhs);
+		elna_tac_instruction_set_op(instruction, 2u, operand);
+		elna_list_append(instructions, cast(instruction: ^ElnaListNode));
+
+		instruction := elna_tac_add_pointer(parser_node^.lhs, lhs, operand, symbol_table, operand);
+		elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+	else
+		elna_tac_binary_create(instructions, ElnaTacOperator.subtract, lhs, rhs, symbol_table, operand)
+	end
+return
+
+proc elna_tac_binary_expression(instructions: ^ElnaList; parser_node: ^ElnaTreeExpression;
+		symbol_table: ^ElnaSymbolTable; operand: ^ElnaTacOperand)
+var
+	binary_node: ^ElnaTreeBinaryExpression
+	instruction: ^ElnaTacInstruction
+	lhs: ElnaTacOperand
+	rhs: ElnaTacOperand
+begin
+	if parser_node^.kind <> ElnaTreeKind.binary_expression then
+		elna_tac_unary_expression(instructions, parser_node, symbol_table, operand)
+	else
+		binary_node := cast(parser_node: ^ElnaTreeBinaryExpression);
+		elna_tac_unary_expression(instructions, binary_node^.lhs, symbol_table, @lhs);
+		elna_tac_unary_expression(instructions, binary_node^.rhs, symbol_table, @rhs);
+
+		case binary_node^.operator of
+			ElnaLexerKind.plus:
+				if binary_node^.lhs^.type_decoration <> nil & binary_node^.lhs^.type_decoration^.kind = ElnaTypeKind.pointer then
+					instruction := elna_tac_add_pointer(binary_node^.lhs, @lhs, @rhs, symbol_table, operand);
+					elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+				elsif binary_node^.rhs^.type_decoration <> nil & binary_node^.rhs^.type_decoration^.kind = ElnaTypeKind.pointer then
+					instruction := elna_tac_add_pointer(binary_node^.rhs, @rhs, @lhs, symbol_table, operand);
+					elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+				else
+					elna_tac_binary_create(instructions, ElnaTacOperator.add, @lhs, @rhs, symbol_table, operand)
+				end
+			| ElnaLexerKind.minus:
+				elna_tac_subtract_create(instructions, binary_node, @lhs, @rhs, symbol_table, operand)
+			| ElnaLexerKind.multiplication:
+				elna_tac_binary_create(instructions, ElnaTacOperator.multiply, @lhs, @rhs, symbol_table, operand)
+			| ElnaLexerKind.division:
+				elna_tac_binary_create(instructions, ElnaTacOperator.divide, @lhs, @rhs, symbol_table, operand)
+			| ElnaLexerKind.remainder:
+				elna_tac_binary_create(instructions, ElnaTacOperator.remainder, @lhs, @rhs, symbol_table, operand)
+			| ElnaLexerKind.and:
+				elna_tac_binary_create(instructions, ElnaTacOperator.and, @lhs, @rhs, symbol_table, operand)
+			| ElnaLexerKind._or:
+				elna_tac_binary_create(instructions, ElnaTacOperator._or, @lhs, @rhs, symbol_table, operand)
+			| ElnaLexerKind._xor:
+				elna_tac_binary_create(instructions, ElnaTacOperator._xor, @lhs, @rhs, symbol_table, operand)
+			| ElnaLexerKind.equals:
+				elna_tac_binary_create(instructions, ElnaTacOperator.equal, @lhs, @rhs, symbol_table, operand)
+			| ElnaLexerKind.not_equal:
+				elna_tac_binary_create(instructions, ElnaTacOperator.not_equal, @lhs, @rhs, symbol_table, operand)
+			| ElnaLexerKind.less_than:
+				elna_tac_binary_create(instructions, ElnaTacOperator.less_than, @lhs, @rhs, symbol_table, operand)
+			| ElnaLexerKind.greater_than:
+				elna_tac_binary_create(instructions, ElnaTacOperator.greater_than, @lhs, @rhs, symbol_table, operand)
+			| ElnaLexerKind.less_equal:
+				elna_tac_binary_create(instructions, ElnaTacOperator.less_or_equal, @lhs, @rhs, symbol_table, operand)
+			| ElnaLexerKind.greater_equal:
+				elna_tac_binary_create(instructions, ElnaTacOperator.greater_or_equal, @lhs, @rhs, symbol_table, operand)
+			else
+		end
+	end
+return
+
+proc elna_tac_call(instructions: ^ElnaList; parsed_call: ^ElnaTreeCall; symbol_table: ^ElnaSymbolTable;
+		operand: ^ElnaTacOperand)
+var
+	parsed_expression: ^ElnaTreeVariableExpression
+	arguments_operand: ^ElnaTacOperand
+	call_instruction: ^ElnaTacInstruction
+	argument_entry: ^ElnaTreeExpressionList
+	symbol_info: ^ElnaSymbolInfo
+	procedure_info: ^ElnaSymbolProcedureInfo
+	i: Word := 0u
+begin
+	parsed_expression := parsed_call^.callee;
+	arguments_operand := malloc#[ElnaTacOperand](parsed_call^.count * #size(ElnaTacOperand));
+	symbol_info := elna_symbol_table_lookup(symbol_table, parsed_expression^.name);
+
+	call_instruction := elna_tac_instruction_create(ElnaTacOperator.proc_call);
+	elna_tac_instruction_set_label(call_instruction, 1u, parsed_expression^.name);
+
+	call_instruction^.operands[2].kind := ElnaTacKind.list;
+	call_instruction^.operands[2].list_operands := arguments_operand;
+	call_instruction^.operands[2].length := parsed_call^.count;
+
+	if symbol_info <> nil & symbol_info^.kind = ElnaSymbolInfoKind.procedure_info then
+		procedure_info := cast(symbol_info: ^ElnaSymbolProcedureInfo);
+		if procedure_info^.procedure_type^.return_type = nil then
+			call_instruction^.operands[3].kind := ElnaTacKind.ignore
+		else
+			elna_tac_make_variable(operand, symbol_table, procedure_info^.procedure_type^.return_type);
+			elna_tac_instruction_set_op(call_instruction, 3u, operand)
+		end
+	else
+		call_instruction^.operands[3].kind := ElnaTacKind.ignore
+	end;
+
+	argument_entry := parsed_call^.arguments;
+	while argument_entry <> nil & i < parsed_call^.count do
+		elna_tac_binary_expression(instructions, argument_entry^.expression, symbol_table, arguments_operand + i);
+		argument_entry := argument_entry^.next;
+		i := i + 1u
+	end;
+	elna_list_append(instructions, cast(call_instruction: ^ElnaListNode))
+return
+
+proc elna_tac_goto_statement(instructions: ^ElnaList; parser_node: ^ElnaTreeGotoStatement)
+var
+	instruction: ^ElnaTacInstruction
+begin
+	instruction := elna_tac_instruction_create(ElnaTacOperator.jump);
+	elna_tac_instruction_set_label(instruction, 1u, parser_node^.label);
+	elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+return
+
+proc elna_tac_label_declaration(instructions: ^ElnaList; parser_node: ^ElnaTreeLabelDeclaration)
+var
+	result: ^ElnaTacInstruction
+begin
+	result := elna_tac_instruction_create(ElnaTacOperator.label);
+	elna_tac_instruction_set_label(result, 1u, parser_node^.label);
+	elna_list_append(instructions, cast(result: ^ElnaListNode))
+return
+
+proc elna_tac_enumeration_value(field_access_expression: ^ElnaTreeFieldAccessExpression; operand: ^ElnaTacOperand)
+var
+	enumeration_type: ^ElnaTypeEnumeration
+	members: ^[]const Word8
+	members_length: Word
+	symbol_info: ^ElnaSymbolInfo
+	type_info: ^ElnaSymbolTypeInfo
+	counter: Word := 1u
+	found: Bool := false
+	aggregate_tree: ^ElnaTreeVariableExpression
+begin
+	aggregate_tree := cast(field_access_expression^.aggregate: ^ElnaTreeVariableExpression);
+	symbol_info := elna_symbol_table_lookup(symbol_table_global, aggregate_tree^.name);
+
+	if symbol_info <> nil & symbol_info^.kind = ElnaSymbolInfoKind.type_info then
+		type_info := cast(symbol_info: ^ElnaSymbolTypeInfo);
+		if type_info^._type^.kind = ElnaTypeKind.enumeration then
+			enumeration_type := cast(type_info^._type: ^ElnaTypeEnumeration);
+			members := enumeration_type^.members;
+			members_length := enumeration_type^.length;
+
+			while members_length > 0u & ~found do
+				if members^ = field_access_expression^.field then
+					found := true;
+					operand^.kind := ElnaTacKind.constant;
+					operand^.constant := counter;
+					operand^.length := 4u;
+					operand^.name := "";
+					operand^.list_operands := nil
+				else
+					members_length := members_length - 1u;
+					members := members + 1u;
+					counter := counter + 1u
+				end
+			end
+		end
+	end
+return
+
+proc elna_tac_dereference_expression(instructions: ^ElnaList; dereference_expression: ^ElnaTreeDereferenceExpression;
+		symbol_table: ^ElnaSymbolTable; operand: ^ElnaTacOperand)
+var
+	load_instruction: ^ElnaTacInstruction
+	operand_result: ElnaTacOperandResult
+	intermediate: ElnaTacOperand
+begin
+	elna_tac_designator(instructions, dereference_expression^.pointer, symbol_table, @operand_result, operand);
+
+	if operand_result.kind = ElnaTacOperandType.dereferenced_pointer then
+		intermediate := operand^;
+		elna_tac_make_variable(operand, symbol_table, word_type);
+
+		load_instruction := elna_tac_instruction_create(ElnaTacOperator.load);
+		elna_tac_instruction_set_op(load_instruction, 1u, @intermediate);
+		elna_tac_instruction_set_op(load_instruction, 2u, operand);
+		elna_list_append(instructions, cast(load_instruction: ^ElnaListNode))
+	elsif operand_result.kind = ElnaTacOperandType.sub_object then
+		intermediate := operand^;
+		elna_tac_make_variable(operand, symbol_table, word_type);
+
+		load_instruction := elna_tac_instruction_create(ElnaTacOperator.copy_from_offset);
+		elna_tac_instruction_set_op(load_instruction, 1u, @intermediate);
+		elna_tac_instruction_set_const(load_instruction, 2u, operand_result.offset, 4u);
+		elna_tac_instruction_set_op(load_instruction, 3u, operand);
+		elna_list_append(instructions, cast(load_instruction: ^ElnaListNode))
+	end
+return
+
+proc elna_tac_field_access_expression(instructions: ^ElnaList; field_access_expression: ^ElnaTreeFieldAccessExpression;
+		symbol_table: ^ElnaSymbolTable; operand_result: ^ElnaTacOperandResult; operand: ^ElnaTacOperand)
+var
+	field_type: ^ElnaType
+	instruction: ^ElnaTacInstruction
+	designator_base: ^ElnaTreeExpression
+	aggregate_type: ^ElnaTypeRecord
+	field_count: Word
+	current_field: ^ElnaTypeField
+	field_offset: Word := 0u
+	base: ElnaTacOperand
+	found: Bool := false
+begin
+	designator_base := field_access_expression^.aggregate;
+	aggregate_type := cast(designator_base^.type_decoration: ^ElnaTypeRecord);
+
+	elna_tac_designator(instructions, designator_base, symbol_table, operand_result, @base);
+
+	if aggregate_type <> nil & aggregate_type^.kind = ElnaTypeKind._record then
+		field_count := aggregate_type^.length;
+		current_field := aggregate_type^.members;
+
+		while field_count > 0u & ~found do
+			if current_field^.name = field_access_expression^.field then
+				found := true
+			else
+				field_type := current_field^.field_type;
+				field_count := field_count - 1u;
+				field_offset := field_offset + field_type^.size;
+				current_field := current_field + 1u
+			end
+		end
+	end;
+
+	if operand_result^.kind = ElnaTacOperandType.dereferenced_pointer then
+		elna_tac_make_variable(operand, symbol_table, word_type);
+
+		instruction := elna_tac_instruction_create(ElnaTacOperator.add);
+		elna_tac_instruction_set_op(instruction, 1u, @base);
+		elna_tac_instruction_set_const(instruction, 2u, field_offset, 4u);
+		elna_tac_instruction_set_op(instruction, 3u, operand);
+		elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+	elsif operand_result^.kind = ElnaTacOperandType.sub_object then
+		operand^ := base;
+		operand_result^.offset := operand_result^.offset + field_offset
+	else
+		operand^ := base;
+		operand_result^.kind := ElnaTacOperandType.sub_object;
+		operand_result^.offset := field_offset
+	end
+return
+
+proc elna_tac_array_access_expression(instructions: ^ElnaList; array_access_expression: ^ElnaTreeArrayAccessExpression;
+		symbol_table: ^ElnaSymbolTable; operand: ^ElnaTacOperand)
+var
+	instruction: ^ElnaTacInstruction
+	operand_result: ElnaTacOperandResult
+	inter_operand: ElnaTacOperand
+	index_operand: ElnaTacOperand
+	aggregate_type: ^ElnaTypeArray
+	designator_base: ^ElnaTreeExpression
+	element_type: ^ElnaType
+	elem_size: Word := 1u
+begin
+	designator_base := array_access_expression^.array;
+	if designator_base^.type_decoration <> nil & designator_base^.type_decoration^.kind = ElnaTypeKind.array then
+		aggregate_type := cast(designator_base^.type_decoration: ^ElnaTypeArray);
+		element_type := aggregate_type^.base;
+		if element_type <> nil then
+			elem_size := element_type^.size
+		end
+	end;
+
+	elna_tac_binary_expression(instructions, array_access_expression^.index, symbol_table, @inter_operand);
+	elna_tac_make_variable(@index_operand, symbol_table, word_type);
+
+	(* In Elna arrays are 1-based, subtract 1 for 0-based index *)
+	instruction := elna_tac_instruction_create(ElnaTacOperator.subtract);
+	elna_tac_instruction_set_op(instruction, 1u, @inter_operand);
+	elna_tac_instruction_set_const(instruction, 2u, 1u, 4u);
+	elna_tac_instruction_set_op(instruction, 3u, @index_operand);
+	elna_list_append(instructions, cast(instruction: ^ElnaListNode));
+
+	elna_tac_designator(instructions, array_access_expression^.array,
+			symbol_table, @operand_result, @inter_operand);
+	elna_tac_make_variable(operand, symbol_table, word_type);
+	elna_tac_copy_address(instructions, @operand_result, @inter_operand, operand);
+
+	instruction := elna_tac_instruction_create(ElnaTacOperator.add_ptr);
+	elna_tac_instruction_set_op(instruction, 1u, operand);
+	elna_tac_instruction_set_op(instruction, 2u, @index_operand);
+	elna_tac_instruction_set_const(instruction, 3u, elem_size, 4u);
+	elna_tac_instruction_set_op(instruction, 4u, operand);
+	elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+return
+
+proc elna_tac_designator(instructions: ^ElnaList; parser_node: ^ElnaTreeExpression; symbol_table: ^ElnaSymbolTable;
+		operand_result: ^ElnaTacOperandResult; operand: ^ElnaTacOperand)
+var
+	field_access_expression: ^ElnaTreeFieldAccessExpression
+	designator_base: ^ElnaTreeExpression
+begin
+	operand_result^.kind := ElnaTacOperandType.plain_object;
+	operand_result^.offset := 0u;
+
+	case parser_node^.kind of
+		ElnaTreeKind.dereference_expression:
+			elna_tac_dereference_expression(instructions, cast(parser_node: ^ElnaTreeDereferenceExpression), symbol_table, operand);
+			operand_result^.kind := ElnaTacOperandType.dereferenced_pointer
+		| ElnaTreeKind.field_access_expression:
+			field_access_expression := cast(parser_node: ^ElnaTreeFieldAccessExpression);
+			designator_base := field_access_expression^.aggregate;
+
+			if designator_base^.type_decoration = nil then
+				elna_tac_enumeration_value(field_access_expression, operand)
+			else
+				elna_tac_field_access_expression(instructions, field_access_expression, symbol_table, operand_result, operand)
+			end
+		| ElnaTreeKind.array_access_expression:
+			elna_tac_array_access_expression(instructions, cast(parser_node: ^ElnaTreeArrayAccessExpression), symbol_table, operand);
+			operand_result^.kind := ElnaTacOperandType.dereferenced_pointer
+		| ElnaTreeKind.call:
+			elna_tac_call(instructions, cast(parser_node: ^ElnaTreeCall), symbol_table, operand)
+		else
+			elna_tac_simple_expression(instructions, parser_node, symbol_table, operand)
+	end
+return
+
+proc elna_tac_assign_statement(instructions: ^ElnaList; parser_tree: ^ElnaTreeAssignStatement; symbol_table: ^ElnaSymbolTable)
+var
+	operand_result: ElnaTacOperandResult
+	instruction: ^ElnaTacInstruction
+	assignment_operand: ElnaTacOperand
+	assignee: ElnaTacOperand
+begin
+	elna_tac_designator(instructions, parser_tree^.assignee, symbol_table, @operand_result, @assignee);
+	elna_tac_binary_expression(instructions, parser_tree^.assignment, symbol_table, @assignment_operand);
+
+	if operand_result.kind = ElnaTacOperandType.dereferenced_pointer then
+		instruction := elna_tac_instruction_create(ElnaTacOperator.store);
+		elna_tac_instruction_set_op(instruction, 1u, @assignment_operand);
+		elna_tac_instruction_set_op(instruction, 2u, @assignee)
+	elsif operand_result.kind = ElnaTacOperandType.sub_object then
+		instruction := elna_tac_instruction_create(ElnaTacOperator.copy_to_offset);
+		elna_tac_instruction_set_op(instruction, 1u, @assignment_operand);
+		elna_tac_instruction_set_op(instruction, 2u, @assignee);
+		elna_tac_instruction_set_const(instruction, 3u, operand_result.offset, 4u)
+	else
+		instruction := elna_tac_instruction_create(ElnaTacOperator.copy);
+		elna_tac_instruction_set_op(instruction, 1u, @assignment_operand);
+		elna_tac_instruction_set_op(instruction, 2u, @assignee)
+	end;
+	elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+return
+
+proc elna_tac_return_statement(instructions: ^ElnaList; parser_node: ^ElnaTreeReturnStatement; symbol_table: ^ElnaSymbolTable)
+var
+	instruction: ^ElnaTacInstruction
+	operand: ElnaTacOperand
+begin
+	instruction := elna_tac_instruction_create(ElnaTacOperator._return);
+	if parser_node^.returned <> nil then
+		elna_tac_binary_expression(instructions, parser_node^.returned, symbol_table, @operand);
+		elna_tac_instruction_set_op(instruction, 1u, @operand)
+	else
+		instruction^.operands[1].kind := ElnaTacKind.ignore
+	end;
+	elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+return
+
+proc elna_tac_conditional_statements(instructions: ^ElnaList; parser_node: ^ElnaTreeConditionalStatements;
+		after_end_label: []const Word8; symbol_table: ^ElnaSymbolTable)
+var
+	condition_label: []const Word8
+	instruction: ^ElnaTacInstruction
+	operand: ElnaTacOperand
+begin
+	elna_tac_binary_expression(instructions, parser_node^.condition, symbol_table, @operand);
+	condition_label := elna_tac_label();
+
+	instruction := elna_tac_instruction_create(ElnaTacOperator.jump_if_zero);
+	elna_tac_instruction_set_op(instruction, 1u, @operand);
+	elna_tac_instruction_set_label(instruction, 2u, condition_label);
+	elna_list_append(instructions, cast(instruction: ^ElnaListNode));
+
+	elna_tac_statements(instructions, parser_node^.statements, symbol_table);
+
+	instruction := elna_tac_instruction_create(ElnaTacOperator.jump);
+	elna_tac_instruction_set_label(instruction, 1u, after_end_label);
+	elna_list_append(instructions, cast(instruction: ^ElnaListNode));
+
+	instruction := elna_tac_instruction_create(ElnaTacOperator.label);
+	elna_tac_instruction_set_label(instruction, 1u, condition_label);
+	elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+return
+
+proc elna_tac_if_statement(instructions: ^ElnaList; parser_node: ^ElnaTreeIfStatement; symbol_table: ^ElnaSymbolTable)
+var
+	current_node: ^ElnaTreeConditionalStatements
+	after_end_label: []const Word8
+	instruction: ^ElnaTacInstruction
+begin
+	after_end_label := elna_tac_label();
+	current_node := parser_node^.conditionals;
+
+	while current_node <> nil do
+		elna_tac_conditional_statements(instructions, current_node, after_end_label, symbol_table);
+		current_node := current_node^.next
+	end;
+
+	if parser_node^._else <> nil then
+		elna_tac_statements(instructions, parser_node^._else, symbol_table)
+	end;
+
+	instruction := elna_tac_instruction_create(ElnaTacOperator.label);
+	elna_tac_instruction_set_label(instruction, 1u, after_end_label);
+	elna_list_append(instructions, cast(instruction: ^ElnaListNode))
+return
+
+proc elna_tac_statement(instructions: ^ElnaList; parser_node: ^ElnaTreeStatement; symbol_table: ^ElnaSymbolTable)
+var
+	operand: ElnaTacOperand
+	call_statement: ^ElnaTreeCallStatement
+begin
+	case parser_node^.kind of
+		ElnaTreeKind.goto_statement:
+			elna_tac_goto_statement(instructions, cast(parser_node: ^ElnaTreeGotoStatement))
+		| ElnaTreeKind.if_statement:
+			elna_tac_if_statement(instructions, cast(parser_node: ^ElnaTreeIfStatement), symbol_table)
+		| ElnaTreeKind.return_statement:
+			elna_tac_return_statement(instructions, cast(parser_node: ^ElnaTreeReturnStatement), symbol_table)
+		| ElnaTreeKind.label_declaration:
+			elna_tac_label_declaration(instructions, cast(parser_node: ^ElnaTreeLabelDeclaration))
+		| ElnaTreeKind.call_statement:
+			call_statement := cast(parser_node: ^ElnaTreeCallStatement);
+			elna_tac_call(instructions, call_statement^.call, symbol_table, @operand)
+		| ElnaTreeKind.assign_statement:
+			elna_tac_assign_statement(instructions, cast(parser_node: ^ElnaTreeAssignStatement), symbol_table)
+		else
+	end
+return
+
+proc elna_tac_statements(instructions: ^ElnaList; current_statement: ^ElnaTreeStatement; symbol_table: ^ElnaSymbolTable)
+var
+	current: ^ElnaTreeStatement
+begin
+	current := current_statement;
+	while current <> nil do
+		elna_tac_statement(instructions, current, symbol_table);
+		current := current^.next
+	end
+return
+
+proc elna_tac_parameters(ast_list: ^ElnaTreeDeclaration; parameter_count: ^Word) -> ^[]const Word8
+var
+	ast_parameter: ^ElnaTreeDeclaration
+	parameter_list: ^[]const Word8
+	count: Word := 0u
+	i: Word := 0u
+begin
+	ast_parameter := ast_list;
+	while ast_parameter <> nil do
+		count := count + 1u;
+		ast_parameter := ast_parameter^.next
+	end;
+	parameter_count^ := count;
+
+	parameter_list := malloc#[[]const Word8](count * #size([]const Word8));
+	ast_parameter := ast_list;
+	while i < count do
+		(parameter_list + i)^ := ast_parameter^.name;
+		i := i + 1u;
+		ast_parameter := ast_parameter^.next
+	end
+return parameter_list
+
+proc elna_tac_procedure_declaration(parser_node: ^ElnaTreeProcedureDeclaration) -> ^ElnaTacProcedure
+var
+	symbol_info: ^ElnaSymbolInfo
+	procedure_info: ^ElnaSymbolProcedureInfo
+	result: ^ElnaTacProcedure
+	parameter_count: Word := 0u
+begin
+	result := malloc#[ElnaTacProcedure](#size(ElnaTacProcedure));
+	result^.next := nil;
+	elna_list_initialize(@result^.body);
+	result^.name := parser_node^.name;
+
+	symbol_info := elna_symbol_table_lookup(symbol_table_global, parser_node^.name);
+	if symbol_info <> nil & symbol_info^.kind = ElnaSymbolInfoKind.procedure_info then
+		procedure_info := cast(symbol_info: ^ElnaSymbolProcedureInfo);
+		result^.symbol_table := procedure_info^.symbol_table
+	else
+		result^.symbol_table := symbol_table_global
+	end;
+
+	result^.parameters := elna_tac_parameters(parser_node^.parameters, @parameter_count);
+	result^.count := parameter_count;
+	pseudo_counter := 0u;
+
+	elna_tac_statements(@result^.body, parser_node^.body, result^.symbol_table)
+return result
+
+proc elna_tac_procedures(parser_node: ^ElnaTreeProcedureDeclaration) -> ^ElnaTacProcedure
+var
+	result: ^ElnaTacProcedure
+	current_procedure: ^ElnaTacProcedure := nil
+	first_procedure: ^ElnaTacProcedure := nil
+	current_node: ^ElnaTreeProcedureDeclaration
+begin
+	current_node := parser_node;
+	while current_node <> nil do
+		if ~current_node^.is_extern then
+			result := elna_tac_procedure_declaration(current_node);
+			if first_procedure = nil then
+				first_procedure := result
+			else
+				current_procedure^.next := result
+			end;
+			current_procedure := result
+		end;
+		current_node := cast(current_node^.next: ^ElnaTreeProcedureDeclaration)
+	end
+return first_procedure
+
+proc elna_tac_variable_declaration(parser_tree: ^ElnaTreeVariableDeclaration) -> ^ElnaTacStaticVariable
+var
+	result: ^ElnaTacStaticVariable
+	symbol_info: ^ElnaSymbolInfo
+	temp_info: ^ElnaSymbolTemporaryInfo
+begin
+	result := malloc#[ElnaTacStaticVariable](#size(ElnaTacStaticVariable));
+	result^.next := nil;
+	result^.name := parser_tree^.name;
+	result^.size := 4u;
+
+	symbol_info := elna_symbol_table_lookup(symbol_table_global, parser_tree^.name);
+	if symbol_info <> nil & symbol_info^.kind = ElnaSymbolInfoKind.temporary_info then
+		temp_info := cast(symbol_info: ^ElnaSymbolTemporaryInfo);
+		if temp_info^.variable_type <> nil then
+			result^.size := temp_info^.variable_type^.size
+		end
+	end
+return result
+
+proc elna_tac_var_part(parser_node: ^ElnaTreeDeclaration) -> ^ElnaTacStaticVariable
+var
+	node: ^ElnaTacStaticVariable
+	current_variable: ^ElnaTacStaticVariable := nil
+	first_variable: ^ElnaTacStaticVariable := nil
+	current_node: ^ElnaTreeDeclaration
+begin
+	current_node := parser_node;
+	while current_node <> nil do
+		node := elna_tac_variable_declaration(cast(current_node: ^ElnaTreeVariableDeclaration));
+		if first_variable = nil then
+			first_variable := node
+		else
+			current_variable^.next := node
+		end;
+		current_variable := node;
+		current_node := current_node^.next
+	end
+return first_variable
+
+proc elna_tac_program_body(parser_node: ^ElnaTreeStatement) -> ^ElnaTacProcedure
+var
+	result: ^ElnaTacProcedure
+	symbol_info: ^ElnaSymbolInfo
+	procedure_info: ^ElnaSymbolProcedureInfo
+begin
+	result := malloc#[ElnaTacProcedure](#size(ElnaTacProcedure));
+	result^.next := nil;
+	elna_list_initialize(@result^.body);
+	result^.name := "main";
+
+	symbol_info := elna_symbol_table_lookup(symbol_table_global, result^.name);
+	if symbol_info <> nil & symbol_info^.kind = ElnaSymbolInfoKind.procedure_info then
+		procedure_info := cast(symbol_info: ^ElnaSymbolProcedureInfo);
+		result^.symbol_table := procedure_info^.symbol_table
+	else
+		result^.symbol_table := symbol_table_global
+	end;
+
+	result^.parameters := nil;
+	result^.count := 0u;
+	pseudo_counter := 0u;
+
+	elna_tac_statements(@result^.body, parser_node, result^.symbol_table)
+return result
+
+proc elna_tac_module_declaration*(parser_node: ^ElnaTreeModuleDeclaration) -> ^ElnaInstructionModule
+var
+	result: ^ElnaInstructionModule
+	last_proc: ^ElnaTacProcedure
+	body_proc: ^ElnaTacProcedure
+begin
+	result := malloc#[ElnaInstructionModule](#size(ElnaInstructionModule));
+	result^.strings := module_strings_first;
+	result^.data := elna_tac_var_part(parser_node^.globals);
+	result^.code := elna_tac_procedures(parser_node^.procedures);
+
+	if parser_node^.body <> nil then
+		body_proc := elna_tac_program_body(parser_node^.body);
+		if result^.code = nil then
+			result^.code := body_proc
+		else
+			last_proc := result^.code;
+			while last_proc^.next <> nil do
+				last_proc := last_proc^.next
+			end;
+			last_proc^.next := body_proc
+		end
+	end;
+	result^.strings := module_strings_first
+return result
+
+end.
diff --git a/source/type_check.elna b/source/type_check.elna
new file mode 100644
index 0000000..8edc30d
--- /dev/null
+++ b/source/type_check.elna
@@ -0,0 +1,315 @@
+(* 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/. *)
+module
+import common, lexer, ast, symbol, diagnostic
+
+proc elna_type_is_aggregate*(_type: ^ElnaType) -> Bool
+var
+	result: Bool := false
+begin
+	if _type <> nil then
+		result := _type^.kind = ElnaTypeKind._record or _type^.kind = ElnaTypeKind.array
+	end
+return result
+
+proc elna_type_character_literal(parser_node: ^ElnaTreeCharacterLiteral)
+begin
+	parser_node^.type_decoration := char_type
+return
+
+proc elna_type_integer_literal(parser_node: ^ElnaTreeIntegerLiteral)
+begin
+	parser_node^.type_decoration := word_type
+return
+
+proc elna_type_string_literal(parser_node: ^ElnaTreeStringLiteral)
+begin
+	parser_node^.type_decoration := cast(string_type: ^ElnaType)
+return
+
+proc elna_type_boolean_literal(parser_node: ^ElnaTreeBooleanLiteral)
+begin
+	parser_node^.type_decoration := bool_type
+return
+
+proc elna_type_nil_literal(parser_node: ^ElnaTreeNilLiteral)
+begin
+	parser_node^.type_decoration := pointer_type
+return
+
+proc elna_type_variable_expression(parser_node: ^ElnaTreeVariableExpression; symbol_table: ^ElnaSymbolTable)
+var
+	variable_info: ^ElnaSymbolInfo
+	temporary_info: ^ElnaSymbolTemporaryInfo
+	procedure_info: ^ElnaSymbolProcedureInfo
+begin
+	variable_info := elna_symbol_table_lookup(symbol_table, parser_node^.name);
+	if variable_info <> nil then
+		if variable_info^.kind = ElnaSymbolInfoKind.temporary_info then
+			temporary_info := cast(variable_info: ^ElnaSymbolTemporaryInfo);
+			parser_node^.type_decoration := temporary_info^.variable_type
+		elsif variable_info^.kind = ElnaSymbolInfoKind.procedure_info then
+			procedure_info := cast(variable_info: ^ElnaSymbolProcedureInfo);
+			parser_node^.type_decoration := cast(procedure_info^.procedure_type: ^ElnaType)
+		end
+	end
+return
+
+proc elna_type_cast_expression(parser_node: ^ElnaTreeCastExpression; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+begin
+	elna_type_binary_expression(parser_node^.expression, symbol_table, error_list)
+return
+
+proc elna_type_call(parser_node: ^ElnaTreeCall; symbol_table: ^ElnaSymbolTable; error_list: ^ElnaList)
+var
+	argument_tree: ^ElnaTreeExpressionList
+	procedure_type: ^ElnaTypeProcedure
+begin
+	argument_tree := parser_node^.arguments;
+
+	elna_type_variable_expression(parser_node^.callee, symbol_table);
+	if parser_node^.callee^.type_decoration <> nil & parser_node^.callee^.type_decoration^.kind = ElnaTypeKind.procedure then
+		procedure_type := cast(parser_node^.callee^.type_decoration: ^ElnaTypeProcedure);
+		parser_node^.type_decoration := procedure_type^.return_type
+	end;
+
+	while argument_tree <> nil do
+		elna_type_binary_expression(argument_tree^.expression, symbol_table, error_list);
+		argument_tree := argument_tree^.next
+	end
+return
+
+proc elna_type_dereference_expression(parser_node: ^ElnaTreeDereferenceExpression; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+var
+	base_type: ^ElnaType := nil
+	pointer_type_node: ^ElnaTypePointer
+begin
+	elna_type_designator(parser_node^.pointer, symbol_table, error_list);
+
+	if parser_node^.pointer^.type_decoration <> nil then
+		base_type := parser_node^.pointer^.type_decoration;
+		if base_type^.kind = ElnaTypeKind.pointer then
+			pointer_type_node := cast(base_type: ^ElnaTypePointer);
+			base_type := pointer_type_node^.base
+		end
+	end;
+	parser_node^.type_decoration := base_type
+return
+
+proc elna_type_field_access_expression(parser_node: ^ElnaTreeFieldAccessExpression; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+var
+	variable_expression: ^ElnaTreeVariableExpression
+	base_type: ^ElnaType := nil
+	type_kind: ^ElnaSymbolTypeInfo
+	symbol_info: ^ElnaSymbolInfo
+	aggregate_type: ^ElnaTypeRecord
+	field_count: Word
+	current_field: ^ElnaTypeField
+begin
+	if parser_node^.aggregate^.kind = ElnaTreeKind.variable_expression then
+		variable_expression := cast(parser_node^.aggregate: ^ElnaTreeVariableExpression);
+		symbol_info := elna_symbol_table_lookup(symbol_table_global, variable_expression^.name);
+		if symbol_info <> nil & symbol_info^.kind = ElnaSymbolInfoKind.type_info then
+			type_kind := cast(symbol_info: ^ElnaSymbolTypeInfo);
+			base_type := type_kind^._type
+		end
+	end;
+
+	if base_type = nil then
+		elna_type_designator(parser_node^.aggregate, symbol_table, error_list);
+		if parser_node^.aggregate^.type_decoration <> nil & parser_node^.aggregate^.type_decoration^.kind = ElnaTypeKind._record then
+			aggregate_type := cast(parser_node^.aggregate^.type_decoration: ^ElnaTypeRecord);
+			field_count := aggregate_type^.length;
+			current_field := aggregate_type^.members;
+
+			while field_count > 0u & base_type = nil do
+				if current_field^.name = parser_node^.field then
+					base_type := current_field^.field_type
+				else
+					field_count := field_count - 1u;
+					current_field := current_field + 1u
+				end
+			end
+		end
+	end;
+
+	parser_node^.type_decoration := base_type
+return
+
+proc elna_type_array_access_expression(parser_node: ^ElnaTreeArrayAccessExpression; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+var
+	aggregate_type: ^ElnaTypeArray
+begin
+	elna_type_designator(parser_node^.array, symbol_table, error_list);
+	elna_type_binary_expression(parser_node^.index, symbol_table, error_list);
+
+	if parser_node^.array^.type_decoration <> nil & parser_node^.array^.type_decoration^.kind = ElnaTypeKind.array then
+		aggregate_type := cast(parser_node^.array^.type_decoration: ^ElnaTypeArray);
+		parser_node^.type_decoration := aggregate_type^.base
+	end
+return
+
+proc elna_type_simple_expression(parser_node: ^ElnaTreeExpression; symbol_table: ^ElnaSymbolTable; error_list: ^ElnaList)
+begin
+	case parser_node^.kind of
+		ElnaTreeKind.integer_literal:
+			elna_type_integer_literal(cast(parser_node: ^ElnaTreeIntegerLiteral))
+		| ElnaTreeKind.character_literal:
+			elna_type_character_literal(cast(parser_node: ^ElnaTreeCharacterLiteral))
+		| ElnaTreeKind.string_literal:
+			elna_type_string_literal(cast(parser_node: ^ElnaTreeStringLiteral))
+		| ElnaTreeKind.boolean_literal:
+			elna_type_boolean_literal(cast(parser_node: ^ElnaTreeBooleanLiteral))
+		| ElnaTreeKind.null:
+			elna_type_nil_literal(cast(parser_node: ^ElnaTreeNilLiteral))
+		| ElnaTreeKind._cast:
+			elna_type_cast_expression(cast(parser_node: ^ElnaTreeCastExpression), symbol_table, error_list)
+		| ElnaTreeKind.variable_expression:
+			elna_type_variable_expression(cast(parser_node: ^ElnaTreeVariableExpression), symbol_table)
+		else
+	end
+return
+
+proc elna_type_designator(parser_node: ^ElnaTreeExpression; symbol_table: ^ElnaSymbolTable; error_list: ^ElnaList)
+begin
+	case parser_node^.kind of
+		ElnaTreeKind.dereference_expression:
+			elna_type_dereference_expression(cast(parser_node: ^ElnaTreeDereferenceExpression), symbol_table, error_list)
+		| ElnaTreeKind.field_access_expression:
+			elna_type_field_access_expression(cast(parser_node: ^ElnaTreeFieldAccessExpression), symbol_table, error_list)
+		| ElnaTreeKind.array_access_expression:
+			elna_type_array_access_expression(cast(parser_node: ^ElnaTreeArrayAccessExpression), symbol_table, error_list)
+		| ElnaTreeKind.call:
+			elna_type_call(cast(parser_node: ^ElnaTreeCall), symbol_table, error_list)
+		else
+			elna_type_simple_expression(parser_node, symbol_table, error_list)
+	end
+return
+
+proc elna_type_unary_expression(parser_node: ^ElnaTreeExpression; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+var
+	unary_node: ^ElnaTreeUnaryExpression
+begin
+	if parser_node^.kind = ElnaTreeKind.unary_expression then
+		unary_node := cast(parser_node: ^ElnaTreeUnaryExpression);
+		elna_type_designator(unary_node^.operand, symbol_table, error_list);
+		parser_node^.type_decoration := unary_node^.operand^.type_decoration
+	else
+		elna_type_designator(parser_node, symbol_table, error_list)
+	end
+return
+
+proc elna_type_binary_expression(parser_node: ^ElnaTreeExpression; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+var
+	binary_node: ^ElnaTreeBinaryExpression
+begin
+	if parser_node <> nil then
+		if parser_node^.kind = ElnaTreeKind.binary_expression then
+			binary_node := cast(parser_node: ^ElnaTreeBinaryExpression);
+			elna_type_unary_expression(binary_node^.rhs, symbol_table, error_list);
+			elna_type_unary_expression(binary_node^.lhs, symbol_table, error_list);
+			parser_node^.type_decoration := binary_node^.lhs^.type_decoration
+		else
+			elna_type_unary_expression(parser_node, symbol_table, error_list)
+		end
+	end
+return
+
+proc elna_type_assign_statement(parser_node: ^ElnaTreeAssignStatement; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+begin
+	elna_type_designator(parser_node^.assignee, symbol_table, error_list);
+	elna_type_binary_expression(parser_node^.assignment, symbol_table, error_list)
+return
+
+proc elna_type_conditional_statements(parser_node: ^ElnaTreeConditionalStatements; symbol_table: ^ElnaSymbolTable;
+		error_list: ^ElnaList)
+var
+	current: ^ElnaTreeConditionalStatements
+begin
+	current := parser_node;
+	while current <> nil do
+		elna_type_binary_expression(current^.condition, symbol_table, error_list);
+		elna_type_statements(current^.statements, symbol_table, error_list);
+		current := current^.next
+	end
+return
+
+proc elna_type_if_statement(parser_node: ^ElnaTreeIfStatement; symbol_table: ^ElnaSymbolTable; error_list: ^ElnaList)
+begin
+	elna_type_conditional_statements(parser_node^.conditionals, symbol_table, error_list);
+	if parser_node^._else <> nil then
+		elna_type_statements(parser_node^._else, symbol_table, error_list)
+	end
+return
+
+proc elna_type_return_statement(parser_node: ^ElnaTreeReturnStatement; symbol_table: ^ElnaSymbolTable; error_list: ^ElnaList)
+begin
+	if parser_node^.returned <> nil then
+		elna_type_binary_expression(parser_node^.returned, symbol_table, error_list)
+	end
+return
+
+proc elna_type_statement(parser_node: ^ElnaTreeStatement; symbol_table: ^ElnaSymbolTable; error_list: ^ElnaList)
+var
+	call_statement: ^ElnaTreeCallStatement
+begin
+	case parser_node^.kind of
+		ElnaTreeKind.if_statement:
+			elna_type_if_statement(cast(parser_node: ^ElnaTreeIfStatement), symbol_table, error_list)
+		| ElnaTreeKind.return_statement:
+			elna_type_return_statement(cast(parser_node: ^ElnaTreeReturnStatement), symbol_table, error_list)
+		| ElnaTreeKind.call_statement:
+			call_statement := cast(parser_node: ^ElnaTreeCallStatement);
+			elna_type_call(call_statement^.call, symbol_table, error_list)
+		| ElnaTreeKind.assign_statement:
+			elna_type_assign_statement(cast(parser_node: ^ElnaTreeAssignStatement), symbol_table, error_list)
+		else
+	end
+return
+
+proc elna_type_statements(parser_node: ^ElnaTreeStatement; symbol_table: ^ElnaSymbolTable; error_list: ^ElnaList)
+var
+	current: ^ElnaTreeStatement
+begin
+	current := parser_node;
+	while current <> nil do
+		elna_type_statement(current, symbol_table, error_list);
+		current := current^.next
+	end
+return
+
+proc elna_type_procedure_declaration(parser_node: ^ElnaTreeProcedureDeclaration; error_list: ^ElnaList)
+var
+	procedure_info: ^ElnaSymbolProcedureInfo
+	symbol_info: ^ElnaSymbolInfo
+begin
+	symbol_info := elna_symbol_table_lookup(symbol_table_global, parser_node^.name);
+	if symbol_info <> nil & symbol_info^.kind = ElnaSymbolInfoKind.procedure_info then
+		procedure_info := cast(symbol_info: ^ElnaSymbolProcedureInfo);
+		elna_type_statements(parser_node^.body, procedure_info^.symbol_table, error_list)
+	end
+return
+
+proc elna_type_module_declaration*(parser_node: ^ElnaTreeModuleDeclaration; error_list: ^ElnaList)
+var
+	current_proc: ^ElnaTreeProcedureDeclaration
+begin
+	current_proc := parser_node^.procedures;
+	while current_proc <> nil do
+		elna_type_procedure_declaration(current_proc, error_list);
+		current_proc := cast(current_proc^.next: ^ElnaTreeProcedureDeclaration)
+	end;
+	if parser_node^.body <> nil then
+		elna_type_statements(parser_node^.body, symbol_table_global, error_list)
+	end
+return
+
+end.