OSS/elna
1
0
Fork 0
Code Issues 12 Pull Requests Releases Activity

Add boolean literals and type

Browse Source
This commit is contained in:
Eugen Wissner
2025-12-02 22:28:40 +01:00
parent 23b6f074c7
commit 1c2a8e6da8
1 changed files with 207 additions and 143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

350
boot/stage17/cl.elna
View File

@@ -7,6 +7,8 @@ program;
(* Stage 17 compiler. *) (* Stage 17 compiler. *)
(* - true and false boolean literals. *)
type type
(** (**
* List of intermediate representation items. * List of intermediate representation items.
@@ -14,6 +16,10 @@ type
ElnaInstructionList = record ElnaInstructionList = record
next: Word next: Word
end; end;
ElnaInstructionModule = record
data: Word;
code: Word
end;
ElnaInstructionDeclaration = record ElnaInstructionDeclaration = record
next: Word; next: Word;
name: Word; name: Word;
@@ -44,6 +50,11 @@ type
kind: Word; kind: Word;
type_decoration: Word type_decoration: Word
end; end;
ElnaTreeBooleanLiteral = record
kind: Word;
type_decoration: Word;
value: Word
end;
ElnaTreeVariableExpression = record ElnaTreeVariableExpression = record
kind: Word; kind: Word;
type_decoration: Word; type_decoration: Word;
@@ -74,28 +85,39 @@ type
operand: Word; operand: Word;
operator: Word operator: Word
end; end;
_if_statement = record
kind: Word;
next: Word;
conditionals: Word;
_else: Word
end;
(** (**
* All statements are chained into a list. Next contains a pointer to the next * All statements are chained into a list. Next contains a pointer to the next
* statement in the statement list. * statement in the statement list.
*) *)
_statement = record ElnaTreeStatement = record
kind: Word; kind: Word;
next: Word next: Word
end; end;
_goto_statement = record ElnaTreeIfStatement = record
kind: Word;
next: Word;
conditionals: Word;
_else: Word
end;
ElnaTreeGotoStatement = record
kind: Word; kind: Word;
next: Word; next: Word;
label: Word; label: Word;
length: Word length: Word
end; end;
_label_declaration = record ElnaTreeAssignStatement = record
kind: Word;
next: Word;
assignee: Word;
assignment: Word
end;
ElnaTreeReturnStatement = record
kind: Word;
next: Word;
returned: Word
end;
ElnaTreeLabelDeclaration = record
kind: Word; kind: Word;
next: Word; next: Word;
label: Word; label: Word;
@@ -113,27 +135,6 @@ type
members: Word; members: Word;
length: Word length: Word
end; end;
ElnaInstructionModule = record
data: Word;
code: Word
end;
_module_declaration = record
kind: Word;
types: Word;
globals: Word;
procedures: Word
end;
_assign_statement = record
kind: Word;
next: Word;
assignee: Word;
assignment: Word
end;
_return_statement = record
kind: Word;
next: Word;
returned: Word
end;
ElnaTreeRecordTypeExpression = record ElnaTreeRecordTypeExpression = record
kind: Word; kind: Word;
members: Word; members: Word;
@@ -153,6 +154,51 @@ type
base: Word; base: Word;
length: Word length: Word
end; end;
(**
* Conditional statements is a list of pairs: condition and statements.
* Used for example to represent if and elsif blocks with beloning statements.
*)
ElnaTreeConditionalStatements = record
condition: Word;
statements: Word;
next: Word
end;
ElnaTreeDeclaration = record
kind: Word;
next: Word;
name: Word;
length: Word
end;
ElnaTreeModuleDeclaration = record
kind: Word;
types: Word;
globals: Word;
procedures: Word
end;
ElnaTreeProcedureDeclaration = record
kind: Word;
next: Word;
name: Word;
length: Word;
body: Word;
temporaries: Word;
parameters: Word
end;
ElnaTreeTypeDeclaration = record
kind: Word;
next: Word;
name: Word;
length: Word;
_type: Word
end;
ElnaTreeVariableDeclaration = record
kind: Word;
next: Word;
name: Word;
length: Word;
_type: Word
end;
ElnaType = record ElnaType = record
kind: Word; kind: Word;
size: Word size: Word
@@ -207,46 +253,6 @@ type
symbol_table: Word symbol_table: Word
end; end;
(**
* Conditional statements is a list of pairs: condition and statements.
* Used for example to represent if and elsif blocks with beloning statements.
*)
_conditional_statements = record
condition: Word;
statements: Word;
next: Word
end;
_declaration = record
kind: Word;
next: Word;
name: Word;
length: Word
end;
_procedure_declaration = record
kind: Word;
next: Word;
name: Word;
length: Word;
body: Word;
temporaries: Word;
parameters: Word
end;
_type_declaration = record
kind: Word;
next: Word;
name: Word;
length: Word;
_type: Word
end;
_variable_declaration = record
kind: Word;
next: Word;
name: Word;
length: Word;
_type: Word
end;
ElnaLexerAction = (none, accumulate, skip, single, eof, finalize, composite, key_id, integer, delimited); ElnaLexerAction = (none, accumulate, skip, single, eof, finalize, composite, key_id, integer, delimited);
(** (**
@@ -317,8 +323,7 @@ type
_do, _do,
_extern, _extern,
_record, _record,
_true, boolean,
_false,
null, null,
and, and,
_or, _or,
@@ -371,6 +376,7 @@ type
integer_literal, integer_literal,
string_literal, string_literal,
character_literal, character_literal,
boolean_literal,
variable_expression, variable_expression,
field_access_expression, field_access_expression,
dereference_expression, dereference_expression,
@@ -1579,6 +1585,23 @@ begin
return result return result
end; end;
proc elna_parser_boolean_literal();
var
boolean_token: Word;
result: ^ElnaTreeBooleanLiteral;
begin
result := malloc(ElnaTreeBooleanLiteral_size());
boolean_token := _elna_lexer_global_get_start();
_elna_lexer_skip_token();
result^.kind := ElnaTreeKind.boolean_literal;
result^.value := string_compare(boolean_token, 4, "true", 4);
result^.type_decoration := nil;
return result
end;
proc elna_parser_nil_literal(); proc elna_parser_nil_literal();
var var
result: ^ElnaTreeNilLiteral; result: ^ElnaTreeNilLiteral;
@@ -1601,6 +1624,15 @@ begin
return nil return nil
end; end;
proc _elna_tac_boolean_literal(boolean_literal_node: ^ElnaTreeBooleanLiteral, operand_type: Word, operand_value: Word, operand_length: Word);
begin
operand_type^ := ElnaTacOperand.immediate;
operand_value^ := boolean_literal_node^.value;
operand_length^ := 0;
return nil
end;
proc _elna_tac_nil_literal(nil_node: Word, operand_type: Word, operand_value: Word, operand_length: Word); proc _elna_tac_nil_literal(nil_node: Word, operand_type: Word, operand_value: Word, operand_length: Word);
begin begin
operand_type^ := ElnaTacOperand.immediate; operand_type^ := ElnaTacOperand.immediate;
@@ -1737,6 +1769,8 @@ begin
parser_node := elna_parser_integer_literal() parser_node := elna_parser_integer_literal()
elsif token_kind = ElnaLexerKind.string then elsif token_kind = ElnaLexerKind.string then
parser_node := elna_parser_string_literal() parser_node := elna_parser_string_literal()
elsif token_kind = ElnaLexerKind.boolean then
parser_node := elna_parser_boolean_literal()
elsif token_kind = ElnaLexerKind.null then elsif token_kind = ElnaLexerKind.null then
parser_node := elna_parser_nil_literal() parser_node := elna_parser_nil_literal()
elsif token_kind = ElnaLexerKind.identifier then elsif token_kind = ElnaLexerKind.identifier then
@@ -1792,6 +1826,8 @@ begin
instruction := _elna_tac_string_literal(parser_node, operand_type, operand_value, operand_length) instruction := _elna_tac_string_literal(parser_node, operand_type, operand_value, operand_length)
elsif parser_node^.kind = ElnaTreeKind.integer_literal then elsif parser_node^.kind = ElnaTreeKind.integer_literal then
instruction := _elna_tac_integer_literal(parser_node, operand_type, operand_value, operand_length) instruction := _elna_tac_integer_literal(parser_node, operand_type, operand_value, operand_length)
elsif parser_node^.kind = ElnaTreeKind.boolean_literal then
instruction := _elna_tac_boolean_literal(parser_node, operand_type, operand_value, operand_length)
elsif parser_node^.kind = ElnaTreeKind.null then elsif parser_node^.kind = ElnaTreeKind.null then
instruction := _elna_tac_nil_literal(parser_node, operand_type, operand_value, operand_length) instruction := _elna_tac_nil_literal(parser_node, operand_type, operand_value, operand_length)
else else
@@ -2105,7 +2141,7 @@ end;
proc elna_parser_call(callee: Word); proc elna_parser_call(callee: Word);
var var
parsed_expression: Word; parsed_expression: Word;
result: ^_statement; result: ^ElnaTreeStatement;
argument_number: Word; argument_number: Word;
token_kind: Word; token_kind: Word;
begin begin
@@ -2230,7 +2266,7 @@ var
token_kind: Word; token_kind: Word;
label_name: Word; label_name: Word;
label_length: Word; label_length: Word;
result: ^_goto_statement; result: ^ElnaTreeGotoStatement;
begin begin
_elna_lexer_skip_token(); _elna_lexer_skip_token();
_elna_lexer_read_token(@token_kind); _elna_lexer_read_token(@token_kind);
@@ -2239,7 +2275,7 @@ begin
label_length := _elna_lexer_global_get_end() - label_name; label_length := _elna_lexer_global_get_end() - label_name;
_elna_lexer_skip_token(); _elna_lexer_skip_token();
result := malloc(_goto_statement_size()); result := malloc(ElnaTreeGotoStatement_size());
result^.kind := ElnaTreeKind.goto_statement; result^.kind := ElnaTreeKind.goto_statement;
result^.next := nil; result^.next := nil;
@@ -2249,7 +2285,7 @@ begin
return result return result
end; end;
proc _elna_tac_goto_statement(parser_node: ^_goto_statement); proc _elna_tac_goto_statement(parser_node: ^ElnaTreeGotoStatement);
var var
label_length: Word; label_length: Word;
label_with_dot: Word; label_with_dot: Word;
@@ -2271,7 +2307,7 @@ var
token_kind: Word; token_kind: Word;
label_name: Word; label_name: Word;
label_length: Word; label_length: Word;
result: ^_goto_statement; result: ^ElnaTreeGotoStatement;
begin begin
_elna_lexer_skip_token(); _elna_lexer_skip_token();
_elna_lexer_read_token(@token_kind); _elna_lexer_read_token(@token_kind);
@@ -2280,7 +2316,7 @@ begin
label_length := _elna_lexer_global_get_end() - label_name; label_length := _elna_lexer_global_get_end() - label_name;
_elna_lexer_skip_token(); _elna_lexer_skip_token();
result := malloc(_label_declaration_size()); result := malloc(ElnaTreeLabelDeclaration_size());
result^.kind := ElnaTreeKind.label_declaration; result^.kind := ElnaTreeKind.label_declaration;
result^.next := nil; result^.next := nil;
@@ -2290,7 +2326,7 @@ begin
return result return result
end; end;
proc _elna_tac_label_declaration(parser_node: ^_label_declaration); proc _elna_tac_label_declaration(parser_node: ^ElnaTreeLabelDeclaration);
return _elna_tac_label(parser_node^.label, parser_node^.length) return _elna_tac_label(parser_node^.label, parser_node^.length)
end; end;
@@ -2447,10 +2483,10 @@ end;
proc elna_parser_assign_statement(assignee: Word); proc elna_parser_assign_statement(assignee: Word);
var var
result: ^_assign_statement; result: ^ElnaTreeAssignStatement;
token_kind: Word; token_kind: Word;
begin begin
result := malloc(_assign_statement_size()); result := malloc(ElnaTreeAssignStatement_size());
result^.kind := ElnaTreeKind.assign_statement; result^.kind := ElnaTreeKind.assign_statement;
result^.next := nil; result^.next := nil;
@@ -2465,7 +2501,7 @@ begin
return result return result
end; end;
proc _elna_tac_assign_statement(parser_tree: ^_assign_statement, symbol_table: Word); proc _elna_tac_assign_statement(parser_tree: ^ElnaTreeAssignStatement, symbol_table: Word);
var var
is_address: Word; is_address: Word;
first_instruction: Word; first_instruction: Word;
@@ -2523,14 +2559,14 @@ var
token_kind: Word; token_kind: Word;
returned: Word; returned: Word;
label_length: Word; label_length: Word;
result: ^_return_statement; result: ^ElnaTreeReturnStatement;
begin begin
(* Skip "return" keyword and whitespace after it. *) (* Skip "return" keyword and whitespace after it. *)
_elna_lexer_skip_token(); _elna_lexer_skip_token();
_elna_lexer_read_token(@token_kind); _elna_lexer_read_token(@token_kind);
returned := elna_parser_binary_expression(); returned := elna_parser_binary_expression();
result := malloc(_return_statement_size()); result := malloc(ElnaTreeReturnStatement_size());
result^.kind := ElnaTreeKind.return_statement; result^.kind := ElnaTreeKind.return_statement;
result^.next := nil; result^.next := nil;
@@ -2539,7 +2575,7 @@ begin
return result return result
end; end;
proc _elna_tac_return_statement(parser_node: ^_return_statement, symbol_table: Word); proc _elna_tac_return_statement(parser_node: ^ElnaTreeReturnStatement, symbol_table: Word);
var var
first_instruction: Word; first_instruction: Word;
instruction: Word; instruction: Word;
@@ -2583,9 +2619,9 @@ end;
proc elna_parser_conditional_statements(); proc elna_parser_conditional_statements();
var var
token_kind: Word; token_kind: Word;
result: ^_conditional_statements; result: ^ElnaTreeConditionalStatements;
begin begin
result := malloc(_conditional_statements_size()); result := malloc(ElnaTreeConditionalStatements_size());
(* Skip "if", "while" or "elsif". *) (* Skip "if", "while" or "elsif". *)
_elna_lexer_skip_token(); _elna_lexer_skip_token();
@@ -2601,7 +2637,7 @@ begin
return result return result
end; end;
proc _elna_tac_conditional_statements(parser_node: ^_conditional_statements, after_end_label: Word, symbol_table: Word); proc _elna_tac_conditional_statements(parser_node: ^ElnaTreeConditionalStatements, after_end_label: Word, symbol_table: Word);
var var
condition_label: Word; condition_label: Word;
instruction: Word; instruction: Word;
@@ -2645,12 +2681,12 @@ end;
proc elna_parser_if_statement(); proc elna_parser_if_statement();
var var
result: ^_if_statement; result: ^ElnaTreeIfStatement;
token_kind: Word; token_kind: Word;
previous_conditional: ^_conditional_statements; previous_conditional: ^ElnaTreeConditionalStatements;
next_conditional: ^_conditional_statements; next_conditional: ^ElnaTreeConditionalStatements;
begin begin
result := malloc(_if_statement_size()); result := malloc(ElnaTreeIfStatement_size());
result^.kind := ElnaTreeKind.if_statement; result^.kind := ElnaTreeKind.if_statement;
result^.next := nil; result^.next := nil;
@@ -2707,9 +2743,9 @@ end;
proc elna_parser_statements(); proc elna_parser_statements();
var var
token_kind: Word; token_kind: Word;
previous_statement: ^_statement; previous_statement: ^ElnaTreeStatement;
next_statement: ^_statement; next_statement: ^ElnaTreeStatement;
first_statement: ^_statement; first_statement: ^ElnaTreeStatement;
begin begin
_skip_empty_lines(); _skip_empty_lines();
@@ -2741,7 +2777,7 @@ end;
proc _elna_tac_statements(parser_node: Word, symbol_table: Word); proc _elna_tac_statements(parser_node: Word, symbol_table: Word);
var var
current_statement: ^_statement; current_statement: ^ElnaTreeStatement;
instruction: Word; instruction: Word;
first_instruction: Word; first_instruction: Word;
current_instruction: Word; current_instruction: Word;
@@ -2767,9 +2803,9 @@ begin
return first_instruction return first_instruction
end; end;
proc _elna_tac_if_statement(parser_node: ^_if_statement, symbol_table: Word); proc _elna_tac_if_statement(parser_node: ^ElnaTreeIfStatement, symbol_table: Word);
var var
current_node: ^_conditional_statements; current_node: ^ElnaTreeConditionalStatements;
after_end_label: Word; after_end_label: Word;
condition_label: Word; condition_label: Word;
first_instruction: Word; first_instruction: Word;
@@ -3269,7 +3305,7 @@ end;
* Parameters: * Parameters:
* parameter_index - Parameter index. * parameter_index - Parameter index.
*) *)
proc elna_name_procedure_parameter(parser_node: ^_variable_declaration, parameter_index: Word, symbol_table: Word); proc elna_name_procedure_parameter(parser_node: ^ElnaTreeVariableDeclaration, parameter_index: Word, symbol_table: Word);
var var
info: Word; info: Word;
variable_type: Word; variable_type: Word;
@@ -3284,7 +3320,7 @@ end;
* Parameters: * Parameters:
* variable_index - Variable index. * variable_index - Variable index.
*) *)
proc elna_name_procedure_temporary(parser_node: ^_variable_declaration, variable_index: Word, symbol_table: Word); proc elna_name_procedure_temporary(parser_node: ^ElnaTreeVariableDeclaration, variable_index: Word, symbol_table: Word);
var var
info: Word; info: Word;
variable_type: Word; variable_type: Word;
@@ -3295,7 +3331,7 @@ begin
_symbol_table_enter(symbol_table, parser_node^.name, parser_node^.length, info) _symbol_table_enter(symbol_table, parser_node^.name, parser_node^.length, info)
end; end;
proc elna_name_procedure_temporaries(parser_node: ^_variable_declaration, symbol_table: Word); proc elna_name_procedure_temporaries(parser_node: ^ElnaTreeVariableDeclaration, symbol_table: Word);
var var
temporary_counter: Word; temporary_counter: Word;
begin begin
@@ -3313,13 +3349,13 @@ end;
proc elna_parser_procedure_declaration(); proc elna_parser_procedure_declaration();
var var
next_declaration: ^_declaration; next_declaration: ^ElnaTreeDeclaration;
current_declaration: ^_declaration; current_declaration: ^ElnaTreeDeclaration;
token_kind: Word; token_kind: Word;
result: ^_procedure_declaration; result: ^ElnaTreeProcedureDeclaration;
parameter_head: ^_declaration; parameter_head: ^ElnaTreeDeclaration;
begin begin
result := malloc(_procedure_declaration_size()); result := malloc(ElnaTreeProcedureDeclaration_size());
result^.kind := ElnaTreeKind.procedure_declaration; result^.kind := ElnaTreeKind.procedure_declaration;
result^.next := nil; result^.next := nil;
@@ -3386,7 +3422,7 @@ begin
return result return result
end; end;
proc _elna_tac_parameters(current_parameter: ^_declaration, new_symbol_table: Word); proc _elna_tac_parameters(current_parameter: ^ElnaTreeDeclaration, new_symbol_table: Word);
var var
name_pointer: Word; name_pointer: Word;
name_length: Word; name_length: Word;
@@ -3460,7 +3496,7 @@ begin
return result return result
end; end;
proc _elna_tac_procedure_declaration(parser_node: _procedure_declaration); proc _elna_tac_procedure_declaration(parser_node: ElnaTreeProcedureDeclaration);
var var
current_parameter: Word; current_parameter: Word;
new_symbol_table: Word; new_symbol_table: Word;
@@ -3494,9 +3530,9 @@ end;
proc elna_parser_procedures(); proc elna_parser_procedures();
var var
parser_node: ^_declaration; parser_node: ^ElnaTreeDeclaration;
result: ^_declaration; result: ^ElnaTreeDeclaration;
current_declaration: ^_declaration; current_declaration: ^ElnaTreeDeclaration;
token_kind: Word; token_kind: Word;
begin begin
result := nil; result := nil;
@@ -3579,7 +3615,7 @@ begin
return first_copy return first_copy
end; end;
proc _elna_tac_procedures(parser_node: ^_declaration); proc _elna_tac_procedures(parser_node: ^ElnaTreeDeclaration);
var var
result: Word; result: Word;
current_procedure: ^ElnaInstructionList; current_procedure: ^ElnaInstructionList;
@@ -3628,7 +3664,7 @@ var
token_kind: Word; token_kind: Word;
type_name: Word; type_name: Word;
name_length: Word; name_length: Word;
result: ^_type_declaration; result: ^ElnaTreeTypeDeclaration;
begin begin
_elna_lexer_read_token(@token_kind); _elna_lexer_read_token(@token_kind);
type_name := _elna_lexer_global_get_start(); type_name := _elna_lexer_global_get_start();
@@ -3638,7 +3674,7 @@ begin
_elna_lexer_read_token(@token_kind); _elna_lexer_read_token(@token_kind);
_elna_lexer_skip_token(); _elna_lexer_skip_token();
result := malloc(_type_declaration_size()); result := malloc(ElnaTreeTypeDeclaration_size());
result^.kind := ElnaTreeKind.type_declaration; result^.kind := ElnaTreeKind.type_declaration;
result^.next := nil; result^.next := nil;
@@ -3652,7 +3688,7 @@ begin
return result return result
end; end;
proc elna_name_type_declaration(parser_node: ^_type_declaration); proc elna_name_type_declaration(parser_node: ^ElnaTreeTypeDeclaration);
var var
type_name: Word; type_name: Word;
name_length: Word; name_length: Word;
@@ -3675,9 +3711,9 @@ end;
proc elna_parser_type_part(); proc elna_parser_type_part();
var var
token_kind: Word; token_kind: Word;
parser_node: ^_declaration; parser_node: ^ElnaTreeDeclaration;
result: ^_declaration; result: ^ElnaTreeDeclaration;
current_declaration: ^_declaration; current_declaration: ^ElnaTreeDeclaration;
begin begin
result := nil; result := nil;
_skip_empty_lines(); _skip_empty_lines();
@@ -3714,7 +3750,7 @@ var
name: Word; name: Word;
name_length: Word; name_length: Word;
variable_type: Word; variable_type: Word;
result: ^_variable_declaration; result: ^ElnaTreeVariableDeclaration;
begin begin
_elna_lexer_read_token(@token_kind); _elna_lexer_read_token(@token_kind);
@@ -3727,7 +3763,7 @@ begin
_elna_lexer_skip_token(); _elna_lexer_skip_token();
variable_type := elna_parser_type_expression(); variable_type := elna_parser_type_expression();
result := malloc(_variable_declaration_size()); result := malloc(ElnaTreeVariableDeclaration_size());
result^.kind := ElnaTreeKind.variable_declaration; result^.kind := ElnaTreeKind.variable_declaration;
result^.next := nil; result^.next := nil;
@@ -3738,7 +3774,7 @@ begin
return result return result
end; end;
proc _elna_tac_variable_declaration(parser_tree: ^_variable_declaration); proc _elna_tac_variable_declaration(parser_tree: ^ElnaTreeVariableDeclaration);
var var
name: Word; name: Word;
name_length: Word; name_length: Word;
@@ -3798,7 +3834,7 @@ begin
return result return result
end; end;
proc _elna_tac_type_part(parser_node: ^_declaration); proc _elna_tac_type_part(parser_node: ^ElnaTreeDeclaration);
var var
result: Word; result: Word;
first_result: Word; first_result: Word;
@@ -3844,7 +3880,7 @@ var
result: Word; result: Word;
token_kind: Word; token_kind: Word;
variable_node: Word; variable_node: Word;
current_declaration: ^_declaration; current_declaration: ^ElnaTreeDeclaration;
begin begin
result := 0; result := 0;
_elna_lexer_read_token(@token_kind); _elna_lexer_read_token(@token_kind);
@@ -3879,7 +3915,7 @@ begin
return result return result
end; end;
proc _elna_tac_var_part(parser_node: ^_declaration); proc _elna_tac_var_part(parser_node: ^ElnaTreeDeclaration);
var var
node: Word; node: Word;
current_variable: ^ElnaInstructionList; current_variable: ^ElnaInstructionList;
@@ -3911,10 +3947,10 @@ end;
proc elna_parser_module_declaration(); proc elna_parser_module_declaration();
var var
parser_node: Word; parser_node: Word;
result: ^_module_declaration; result: ^ElnaTreeModuleDeclaration;
token_kind: Word; token_kind: Word;
begin begin
result := malloc(_module_declaration_size()); result := malloc(ElnaTreeModuleDeclaration_size());
result^.kind := ElnaTreeKind.module_declaration; result^.kind := ElnaTreeKind.module_declaration;
(* Skip "program;". *) (* Skip "program;". *)
@@ -3934,7 +3970,7 @@ end;
(** (**
* Process the source code and print the generated code. * Process the source code and print the generated code.
*) *)
proc _elna_tac_module_declaration(parser_node: ^_module_declaration); proc _elna_tac_module_declaration(parser_node: ^ElnaTreeModuleDeclaration);
var var
data_part: Word; data_part: Word;
code_part: Word; code_part: Word;
@@ -3960,12 +3996,12 @@ begin
return elna_instruction_module_create(data_part, code_part) return elna_instruction_module_create(data_part, code_part)
end; end;
proc elna_name_procedure_declaration(parser_node: ^_procedure_declaration); proc elna_name_procedure_declaration(parser_node: ^ElnaTreeProcedureDeclaration);
var var
new_symbol_table: Word; new_symbol_table: Word;
parameter_counter: Word; parameter_counter: Word;
symbol_info: Word; symbol_info: Word;
current_parameter: ^_declaration; current_parameter: ^ElnaTreeDeclaration;
begin begin
new_symbol_table := _symbol_table_create(); new_symbol_table := _symbol_table_create();
symbol_info := _procedure_info_create(new_symbol_table); symbol_info := _procedure_info_create(new_symbol_table);
@@ -3985,7 +4021,7 @@ begin
_symbol_table_enter(@symbol_table_global, parser_node^.name, parser_node^.length, symbol_info) _symbol_table_enter(@symbol_table_global, parser_node^.name, parser_node^.length, symbol_info)
end; end;
proc elna_type_conditional_statements(parser_node: ^_conditional_statements, symbol_table: Word); proc elna_type_conditional_statements(parser_node: ^ElnaTreeConditionalStatements, symbol_table: Word);
begin begin
.elna_type_conditional_statements_loop; .elna_type_conditional_statements_loop;
elna_type_binary_expression(parser_node^.condition, symbol_table); elna_type_binary_expression(parser_node^.condition, symbol_table);
@@ -3997,9 +4033,9 @@ begin
end end
end; end;
proc elna_type_if_statement(parser_node: ^_if_statement, symbol_table: Word); proc elna_type_if_statement(parser_node: ^ElnaTreeIfStatement, symbol_table: Word);
var var
block: ^_conditional_statements; block: ^ElnaTreeConditionalStatements;
begin begin
block := parser_node^.conditionals; block := parser_node^.conditionals;
@@ -4016,7 +4052,7 @@ begin
end end
end; end;
proc elna_type_return_statement(parser_node: ^_return_statement, symbol_table: Word); proc elna_type_return_statement(parser_node: ^ElnaTreeReturnStatement, symbol_table: Word);
begin begin
elna_type_binary_expression(parser_node^.returned, symbol_table) elna_type_binary_expression(parser_node^.returned, symbol_table)
end; end;
@@ -4039,7 +4075,7 @@ begin
end end
end; end;
proc elna_type_assign_statement(parser_node: ^_assign_statement, symbol_table: Word); proc elna_type_assign_statement(parser_node: ^ElnaTreeAssignStatement, symbol_table: Word);
begin begin
elna_type_designator(parser_node^.assignee, symbol_table); elna_type_designator(parser_node^.assignee, symbol_table);
elna_type_binary_expression(parser_node^.assignment, symbol_table) elna_type_binary_expression(parser_node^.assignment, symbol_table)
@@ -4059,7 +4095,7 @@ begin
end end
end; end;
proc elna_type_statements(parser_node: ^_statement, symbol_table: Word); proc elna_type_statements(parser_node: ^ElnaTreeStatement, symbol_table: Word);
begin begin
.elna_type_statements_loop; .elna_type_statements_loop;
if parser_node <> nil then if parser_node <> nil then
@@ -4094,11 +4130,19 @@ begin
parser_node^.type_decoration := symbol_info^._type parser_node^.type_decoration := symbol_info^._type
end; end;
proc elna_type_boolean_literal(parser_node: ^ElnaTreeBooleanLiteral);
var
symbol_info: ^_type_info;
begin
symbol_info := _symbol_table_lookup(@symbol_table_global, "Bool", 4);
parser_node^.type_decoration := symbol_info^._type
end;
proc elna_type_nil_literal(parser_node: ^ElnaTreeNilLiteral); proc elna_type_nil_literal(parser_node: ^ElnaTreeNilLiteral);
var var
symbol_info: ^_type_info; symbol_info: ^_type_info;
begin begin
symbol_info := _symbol_table_lookup(@symbol_table_global, "Word", 4); symbol_info := _symbol_table_lookup(@symbol_table_global, "Pointer", 7);
parser_node^.type_decoration := symbol_info^._type parser_node^.type_decoration := symbol_info^._type
end; end;
@@ -4131,6 +4175,8 @@ begin
elna_type_character_literal(parser_node) elna_type_character_literal(parser_node)
elsif parser_node^.kind = ElnaTreeKind.string_literal then elsif parser_node^.kind = ElnaTreeKind.string_literal then
elna_type_string_literal(parser_node) elna_type_string_literal(parser_node)
elsif parser_node^.kind = ElnaTreeKind.boolean_literal then
elna_type_boolean_literal(parser_node)
elsif parser_node^.kind = ElnaTreeKind.null then elsif parser_node^.kind = ElnaTreeKind.null then
elna_type_nil_literal(parser_node) elna_type_nil_literal(parser_node)
elsif parser_node^.kind = ElnaTreeKind.variable_expression then elsif parser_node^.kind = ElnaTreeKind.variable_expression then
@@ -4250,7 +4296,7 @@ begin
end end
end; end;
proc elna_type_procedure_declaration(parser_node: ^_procedure_declaration); proc elna_type_procedure_declaration(parser_node: ^ElnaTreeProcedureDeclaration);
var var
procedure_info: ^_procedure_info; procedure_info: ^_procedure_info;
symbol_table: Word; symbol_table: Word;
@@ -4261,9 +4307,9 @@ begin
elna_type_statements(parser_node^.body, symbol_table) elna_type_statements(parser_node^.body, symbol_table)
end; end;
proc elna_name_module_declaration(parser_node: ^_module_declaration); proc elna_name_module_declaration(parser_node: ^ElnaTreeModuleDeclaration);
var var
current_part: ^_declaration; current_part: ^ElnaTreeDeclaration;
begin begin
current_part := parser_node^.types; current_part := parser_node^.types;
.elna_name_module_declaration_type; .elna_name_module_declaration_type;
@@ -4291,9 +4337,9 @@ begin
end end
end; end;
proc elna_type_module_declaration(parser_node: ^_module_declaration); proc elna_type_module_declaration(parser_node: ^ElnaTreeModuleDeclaration);
var var
current_part: ^_declaration; current_part: ^ElnaTreeDeclaration;
begin begin
current_part := parser_node^.types; current_part := parser_node^.types;
.elna_type_module_declaration_type; .elna_type_module_declaration_type;
@@ -4462,14 +4508,28 @@ begin
(* Set the table length to 0. *) (* Set the table length to 0. *)
symbol_table_global := 0; symbol_table_global := 0;
(* Enter built-in symbols. *)
current_type := malloc(ElnaType_size()); current_type := malloc(ElnaType_size());
current_type^.kind := ElnaTypeKind.primitive; current_type^.kind := ElnaTypeKind.primitive;
current_type^.size := 4; current_type^.size := 4;
(* Enter built-in symbols. *)
current_info := _type_info_create(current_type); current_info := _type_info_create(current_type);
_symbol_table_enter(@symbol_table_global, "Word", 4, current_info); _symbol_table_enter(@symbol_table_global, "Word", 4, current_info);
current_type := malloc(ElnaType_size());
current_type^.kind := ElnaTypeKind.primitive;
current_type^.size := 4;
current_info := _type_info_create(current_type);
_symbol_table_enter(@symbol_table_global, "Pointer", 7, current_info);
current_type := malloc(ElnaType_size());
current_type^.kind := ElnaTypeKind.primitive;
current_type^.size := 1;
current_info := _type_info_create(current_type);
_symbol_table_enter(@symbol_table_global, "Bool", 4, current_info);
current_type := malloc(ElnaType_size());
current_type^.kind := ElnaTypeKind.primitive;
current_type^.size := 4096;
current_info := _type_info_create(current_type); current_info := _type_info_create(current_type);
_symbol_table_enter(@symbol_table_global, "Array", 5, current_info) _symbol_table_enter(@symbol_table_global, "Array", 5, current_info)
end; end;
@@ -5034,6 +5094,10 @@ begin
result := ElnaLexerKind._module result := ElnaLexerKind._module
elsif string_compare(position_start, token_length, "nil", 3) then elsif string_compare(position_start, token_length, "nil", 3) then
result := ElnaLexerKind.null result := ElnaLexerKind.null
elsif string_compare(position_start, token_length, "true", 4) then
result := ElnaLexerKind.boolean
elsif string_compare(position_start, token_length, "false", 5) then
result := ElnaLexerKind.boolean
end; end;
return result return result
end; end;