belka/elna
1
0
Fork 0
Code Issues 7 Pull Requests Releases Activity

Use array range beginning with one

Browse Source
This commit is contained in:
Eugen Wissner
2025-07-17 11:44:42 +02:00
parent 34abb6b4f5
commit 32d4683315
4 changed files with 370 additions and 372 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
gcc/elna-generic.cc
View File

@ -154,7 +154,9 @@ namespace elna::gcc
}
else if (constant_expression != boolean_true_node)
{
this->current_expression = call_built_in(call_location, "__builtin_trap", void_type_node);
tree assert_expression = call_built_in(call_location, "__builtin_trap", void_type_node);
this->current_expression = build3(COND_EXPR, void_type_node, this->current_expression,
NULL_TREE, assert_expression);
}
else
{
@ -486,7 +488,6 @@ namespace elna::gcc
{
gcc_unreachable();
}
if (left_type == elna_bool_type_node)
{
return build2_loc(expression_location, logical_code, elna_bool_type_node, left, right);
@ -497,8 +498,7 @@ namespace elna::gcc
}
else
{
error_at(expression_location,
"Invalid operands of type '%s' and '%s' for operator %s",
error_at(expression_location, "Invalid operands of type '%s' and '%s' for operator %s",
print_type(left_type).c_str(), print_type(right_type).c_str(),
elna::boot::print_binary_operator(expression->operation()));
return error_mark_node;
@ -810,21 +810,18 @@ namespace elna::gcc
this->current_expression = error_mark_node;
return;
}
if (this->current_expression != elna_word_type_node)
{
this->current_expression = convert(elna_word_type_node, this->current_expression);
}
tree offset = build2(MINUS_EXPR, elna_word_type_node, this->current_expression, size_one_node);
tree offset = fold_convert(elna_word_type_node, this->current_expression);
if (TREE_CODE(TREE_TYPE(designator)) == ARRAY_TYPE)
{
tree element_type = TREE_TYPE(TREE_TYPE(designator));
this->current_expression = build4_loc(location,
ARRAY_REF, element_type, designator, offset, NULL_TREE, NULL_TREE);
ARRAY_REF, element_type, designator, offset, size_one_node, NULL_TREE);
}
else if (TREE_TYPE(designator) == elna_string_type_node)
{
offset = build2(MINUS_EXPR, elna_word_type_node, offset, size_one_node);
tree string_ptr = build3_loc(location, COMPONENT_REF, TREE_TYPE(elna_string_ptr_field_node),
designator, elna_string_ptr_field_node, NULL_TREE);

4
gcc/elna-tree.cc
View File

@ -21,7 +21,6 @@ along with GCC; see the file COPYING3. If not see
#include "function.h"
#include "stor-layout.h"
#include "fold-const.h"
#include "diagnostic-core.h"
namespace elna::gcc
@ -248,9 +247,8 @@ namespace elna::gcc
tree build_static_array_type(tree type, const std::uint64_t size)
{
tree lower_bound = build_int_cst_type(integer_type_node, 0);
tree upper_bound = build_int_cst_type(integer_type_node, size);
tree range_type = build_range_type(integer_type_node, lower_bound, upper_bound);
tree range_type = build_range_type(integer_type_node, size_one_node, upper_bound);
return build_array_type(type, range_type);
}

5
include/elna/gcc/elna-tree.h
View File

@ -25,6 +25,7 @@ along with GCC; see the file COPYING3. If not see
#include "tree.h"
#include "tree-iterator.h"
#include "stringpool.h"
#include "fold-const.h"
#include "elna/boot/ast.h"
#include "elna/boot/symbol.h"
@ -97,6 +98,8 @@ namespace elna::gcc
tree fndecl_type = build_function_type(return_type, TYPE_ARG_TYPES(*builtin));
tree builtin_addr = build1_loc(call_location, ADDR_EXPR, build_pointer_type(fndecl_type), *builtin);
return build_call_nary(return_type, builtin_addr, sizeof...(Args), arguments...);
tree argument_trees[sizeof...(Args)] = {arguments...};
return fold_build_call_array(return_type, builtin_addr, sizeof...(Args), argument_trees);
}
}

716
source/main.elna
View File

@ -196,10 +196,10 @@ begin
end;
while value <> 0 do
digit := value % 10;
value := value / 10;
value := value / 10;
buffer[n] := cast(cast('0': Int) + digit: Char);
n := n - 1u
buffer[n] := cast(cast('0': Int) + digit: Char);
n := n - 1u
end;
while n < 10u do
n := n + 1u;
@ -309,7 +309,7 @@ begin
if source_file^.index > source_file^.size then
source_file^.size := fread(cast(@source_file^.buffer: Pointer), 1u, 1024u, source_file^.handle);
source_file^.index := 1u
source_file^.index := 1u
end;
return source_file^.size = 0u
@ -366,41 +366,41 @@ var
successful: Bool;
begin
if escape = 'n' then
result^ := '\n';
successful := true
result^ := '\n';
successful := true
elsif escape = 'a' then
result^ := '\a';
successful := true
result^ := '\a';
successful := true
elsif escape = 'b' then
result^ := '\b';
successful := true
result^ := '\b';
successful := true
elsif escape = 't' then
result^ := '\t';
successful := true
result^ := '\t';
successful := true
elsif escape = 'f' then
result^ := '\f';
successful := true
result^ := '\f';
successful := true
elsif escape = 'r' then
result^ := '\r';
successful := true
result^ := '\r';
successful := true
elsif escape = 'v' then
result^ := '\v';
successful := true
result^ := '\v';
successful := true
elsif escape = '\\' then
result^ := '\\';
successful := true
result^ := '\\';
successful := true
elsif escape = '\'' then
result^ := '\'';
successful := true
result^ := '\'';
successful := true
elsif escape = '"' then
result^ := '"';
successful := true
result^ := '"';
successful := true
elsif escape = '?' then
result^ := '\?';
successful := true
result^ := '\?';
successful := true
elsif escape = '0' then
result^ := '\0';
successful := true
result^ := '\0';
successful := true
else
successful := false
end;
@ -417,8 +417,8 @@ begin
if current = '\n' then
source_code_break(source_code)
end;
source_code_advance(source_code)
end;
source_code_advance(source_code)
end
end;
@ -433,7 +433,7 @@ var
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)
source_code_advance(source_code)
end
end;
@ -445,15 +445,15 @@ begin
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_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;
trailing := 2u
else
string_buffer_push(token_content, source_code_head(source_code^));
trailing := 0u
end;
source_code_advance(source_code)
end;
@ -471,9 +471,9 @@ begin
source_code_advance(source_code);
successful := ~source_code_empty(source_code) & lexer_escape(source_code_head(source_code^), token_content)
else
else
token_content^ := source_code_head(source_code^);
successful := true
successful := true
end
end;
if successful then
@ -524,64 +524,64 @@ var
current_token: Token;
begin
if token_content = "if" then
current_token.kind := TokenKind._if
current_token.kind := TokenKind._if
elsif token_content = "then" then
current_token.kind := TokenKind._then
current_token.kind := TokenKind._then
elsif token_content = "else" then
current_token.kind := TokenKind._else
current_token.kind := TokenKind._else
elsif token_content = "elsif" then
current_token.kind := TokenKind._elsif
current_token.kind := TokenKind._elsif
elsif token_content = "while" then
current_token.kind := TokenKind._while
current_token.kind := TokenKind._while
elsif token_content = "do" then
current_token.kind := TokenKind._do
current_token.kind := TokenKind._do
elsif token_content = "proc" then
current_token.kind := TokenKind._proc
current_token.kind := TokenKind._proc
elsif token_content = "begin" then
current_token.kind := TokenKind._begin
current_token.kind := TokenKind._begin
elsif token_content = "end" then
current_token.kind := TokenKind._end
current_token.kind := TokenKind._end
elsif token_content = "extern" then
current_token.kind := TokenKind._extern
current_token.kind := TokenKind._extern
elsif token_content = "const" then
current_token.kind := TokenKind._const
current_token.kind := TokenKind._const
elsif token_content = "var" then
current_token.kind := TokenKind._var
current_token.kind := TokenKind._var
elsif token_content = "case" then
current_token.kind := TokenKind._case
current_token.kind := TokenKind._case
elsif token_content = "of" then
current_token.kind := TokenKind._of
current_token.kind := TokenKind._of
elsif token_content = "type" then
current_token.kind := TokenKind._type
current_token.kind := TokenKind._type
elsif token_content = "record" then
current_token.kind := TokenKind._record
current_token.kind := TokenKind._record
elsif token_content = "union" then
current_token.kind := TokenKind._union
current_token.kind := TokenKind._union
elsif token_content = "true" then
current_token.kind := TokenKind.boolean;
current_token.value.boolean_value := true
current_token.kind := TokenKind.boolean;
current_token.value.boolean_value := true
elsif token_content = "false" then
current_token.kind := TokenKind.boolean;
current_token.value.boolean_value := false
current_token.kind := TokenKind.boolean;
current_token.value.boolean_value := false
elsif token_content = "nil" then
current_token.kind := TokenKind.null
current_token.kind := TokenKind.null
elsif token_content = "or" then
current_token.kind := TokenKind._or
current_token.kind := TokenKind._or
elsif token_content = "return" then
current_token.kind := TokenKind._return
current_token.kind := TokenKind._return
elsif token_content = "cast" then
current_token.kind := TokenKind._cast
current_token.kind := TokenKind._cast
elsif token_content = "defer" then
current_token.kind := TokenKind._defer
current_token.kind := TokenKind._defer
elsif token_content = "program" then
current_token.kind := TokenKind._program
current_token.kind := TokenKind._program
elsif token_content = "module" then
current_token.kind := TokenKind._module
elsif token_content = "import" then
current_token.kind := TokenKind._import
else
current_token.kind := TokenKind.identifier;
current_token.value.string := string_dup(token_content)
current_token.kind := TokenKind.identifier;
current_token.value.string := string_dup(token_content)
end;
return current_token
@ -611,162 +611,162 @@ begin
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);
source_code_advance(@source_code);
lexer_identifier(@source_code, token_buffer);
current_token.kind := TokenKind.trait;
current_token.value.string := string_dup(string_buffer_clear(token_buffer))
current_token.kind := TokenKind.trait;
current_token.value.string := string_dup(string_buffer_clear(token_buffer))
elsif is_digit(first_char) then
lexer_number(@source_code, @current_token.value.int_value);
lexer_number(@source_code, @current_token.value.int_value);
if source_code_expect(@source_code, 'u') then
current_token.kind := TokenKind.word;
source_code_advance(@source_code)
else
current_token.kind := TokenKind.integer
end
if source_code_expect(@source_code, 'u') then
current_token.kind := TokenKind.word;
source_code_advance(@source_code)
else
current_token.kind := TokenKind.integer
end
elsif first_char = '(' then
source_code_advance(@source_code);
source_code_advance(@source_code);
if source_code_empty(@source_code) then
current_token.kind := TokenKind.left_paren
elsif source_code_head(source_code) = '*' then
source_code_advance(@source_code);
if source_code_empty(@source_code) then
current_token.kind := TokenKind.left_paren
elsif source_code_head(source_code) = '*' then
source_code_advance(@source_code);
if lexer_comment(@source_code, token_buffer) then
current_token.value.string := string_dup(string_buffer_clear(token_buffer));
current_token.kind := TokenKind.comment
else
current_token.kind := TokenKind.unknown
end
else
current_token.kind := TokenKind.left_paren
end
if lexer_comment(@source_code, token_buffer) then
current_token.value.string := string_dup(string_buffer_clear(token_buffer));
current_token.kind := TokenKind.comment
else
current_token.kind := TokenKind.unknown
end
else
current_token.kind := TokenKind.left_paren
end
elsif first_char = ')' then
current_token.kind := TokenKind.right_paren;
source_code_advance(@source_code)
current_token.kind := TokenKind.right_paren;
source_code_advance(@source_code)
elsif first_char = '\'' then
source_code_advance(@source_code);
if lexer_character(@source_code, @current_token.value.char_value) & source_code_expect(@source_code, '\'') then
current_token.kind := TokenKind.character;
source_code_advance(@source_code)
else
current_token.kind := TokenKind.unknown
end
if lexer_character(@source_code, @current_token.value.char_value) & source_code_expect(@source_code, '\'') then
current_token.kind := TokenKind.character;
source_code_advance(@source_code)
else
current_token.kind := TokenKind.unknown
end
elsif first_char = '"' then
source_code_advance(@source_code);
if lexer_string(@source_code, token_buffer) then
current_token.kind := TokenKind.string;
current_token.value.string := string_dup(string_buffer_clear(token_buffer))
else
current_token.kind := TokenKind.unknown
end
current_token.kind := TokenKind.string;
current_token.value.string := string_dup(string_buffer_clear(token_buffer))
else
current_token.kind := TokenKind.unknown
end
elsif first_char = '[' then
current_token.kind := TokenKind.left_square;
source_code_advance(@source_code)
current_token.kind := TokenKind.left_square;
source_code_advance(@source_code)
elsif first_char = ']' then
current_token.kind := TokenKind.right_square;
source_code_advance(@source_code)
current_token.kind := TokenKind.right_square;
source_code_advance(@source_code)
elsif first_char = '>' then
source_code_advance(@source_code);
source_code_advance(@source_code);
if source_code_empty(@source_code) then
current_token.kind := TokenKind.greater_than
elsif source_code_head(source_code) = '=' then
current_token.kind := TokenKind.greater_equal;
source_code_advance(@source_code)
elsif source_code_head(source_code) = '>' then
current_token.kind := TokenKind.shift_right;
source_code_advance(@source_code)
else
current_token.kind := TokenKind.greater_than
end
current_token.kind := TokenKind.greater_than
elsif source_code_head(source_code) = '=' then
current_token.kind := TokenKind.greater_equal;
source_code_advance(@source_code)
elsif source_code_head(source_code) = '>' then
current_token.kind := TokenKind.shift_right;
source_code_advance(@source_code)
else
current_token.kind := TokenKind.greater_than
end
elsif first_char = '<' then
source_code_advance(@source_code);
if source_code_empty(@source_code) then
current_token.kind := TokenKind.less_than
elsif source_code_head(source_code) = '=' then
current_token.kind := TokenKind.less_equal;
source_code_advance(@source_code)
elsif source_code_head(source_code) = '<' then
current_token.kind := TokenKind.shift_left;
source_code_advance(@source_code)
elsif source_code_head(source_code) = '>' then
current_token.kind := TokenKind.not_equal;
source_code_advance(@source_code)
else
current_token.kind := TokenKind.less_than
end
elsif first_char = '=' then
current_token.kind := TokenKind.equal;
source_code_advance(@source_code)
elsif first_char = ';' then
current_token.kind := TokenKind.semicolon;
source_code_advance(@source_code)
elsif first_char = '.' then
current_token.kind := TokenKind.dot;
source_code_advance(@source_code)
elsif first_char = ',' then
current_token.kind := TokenKind.comma;
source_code_advance(@source_code)
elsif first_char = '+' then
current_token.kind := TokenKind.plus;
source_code_advance(@source_code)
elsif first_char = '-' then
source_code_advance(@source_code);
source_code_advance(@source_code);
if source_code_empty(@source_code) then
current_token.kind := TokenKind.minus
elsif source_code_head(source_code) = '>' then
current_token.kind := TokenKind.arrow;
source_code_advance(@source_code)
else
current_token.kind := TokenKind.minus
end
elsif first_char = '*' then
current_token.kind := TokenKind.multiplication;
source_code_advance(@source_code)
elsif first_char = '/' then
current_token.kind := TokenKind.division;
source_code_advance(@source_code)
elsif first_char = '%' then
current_token.kind := TokenKind.remainder;
source_code_advance(@source_code)
elsif first_char = ':' then
source_code_advance(@source_code);
current_token.kind := TokenKind.less_than
elsif source_code_head(source_code) = '=' then
current_token.kind := TokenKind.less_equal;
source_code_advance(@source_code)
elsif source_code_head(source_code) = '<' then
current_token.kind := TokenKind.shift_left;
source_code_advance(@source_code)
elsif source_code_head(source_code) = '>' then
current_token.kind := TokenKind.not_equal;
source_code_advance(@source_code)
else
current_token.kind := TokenKind.less_than
end
elsif first_char = '=' then
current_token.kind := TokenKind.equal;
source_code_advance(@source_code)
elsif first_char = ';' then
current_token.kind := TokenKind.semicolon;
source_code_advance(@source_code)
elsif first_char = '.' then
current_token.kind := TokenKind.dot;
source_code_advance(@source_code)
elsif first_char = ',' then
current_token.kind := TokenKind.comma;
source_code_advance(@source_code)
elsif first_char = '+' then
current_token.kind := TokenKind.plus;
source_code_advance(@source_code)
elsif first_char = '-' then
source_code_advance(@source_code);
if source_code_empty(@source_code) then
current_token.kind := TokenKind.colon
elsif source_code_head(source_code) = '=' then
current_token.kind := TokenKind.assignment;
source_code_advance(@source_code)
else
current_token.kind := TokenKind.colon
end
if source_code_empty(@source_code) then
current_token.kind := TokenKind.minus
elsif source_code_head(source_code) = '>' then
current_token.kind := TokenKind.arrow;
source_code_advance(@source_code)
else
current_token.kind := TokenKind.minus
end
elsif first_char = '*' then
current_token.kind := TokenKind.multiplication;
source_code_advance(@source_code)
elsif first_char = '/' then
current_token.kind := TokenKind.division;
source_code_advance(@source_code)
elsif first_char = '%' then
current_token.kind := TokenKind.remainder;
source_code_advance(@source_code)
elsif first_char = ':' then
source_code_advance(@source_code);
if source_code_empty(@source_code) then
current_token.kind := TokenKind.colon
elsif source_code_head(source_code) = '=' then
current_token.kind := TokenKind.assignment;
source_code_advance(@source_code)
else
current_token.kind := TokenKind.colon
end
elsif first_char = '^' then
current_token.kind := TokenKind.hat;
source_code_advance(@source_code)
current_token.kind := TokenKind.hat;
source_code_advance(@source_code)
elsif first_char = '@' then
current_token.kind := TokenKind.at;
source_code_advance(@source_code)
current_token.kind := TokenKind.at;
source_code_advance(@source_code)
elsif first_char = '!' then
current_token.kind := TokenKind.exclamation;
source_code_advance(@source_code)
current_token.kind := TokenKind.exclamation;
source_code_advance(@source_code)
elsif first_char = '&' then
current_token.kind := TokenKind.and;
source_code_advance(@source_code)
current_token.kind := TokenKind.and;
source_code_advance(@source_code)
elsif first_char = '~' then
current_token.kind := TokenKind.not;
source_code_advance(@source_code)
current_token.kind := TokenKind.not;
source_code_advance(@source_code)
elsif first_char = '|' then
current_token.kind := TokenKind.pipe;
source_code_advance(@source_code)
current_token.kind := TokenKind.pipe;
source_code_advance(@source_code)
else
current_token.kind := TokenKind.unknown;
source_code_advance(@source_code)
current_token.kind := TokenKind.unknown;
source_code_advance(@source_code)
end;
return current_token
@ -785,16 +785,16 @@ begin
lexer_spaces(@source_code);
while ~source_code_empty(@source_code) do
current_token := lexer_next(source_code, @token_buffer);
current_token := lexer_next(source_code, @token_buffer);
if current_token.kind <> TokenKind.unknown 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
if current_token.kind <> TokenKind.unknown 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
@ -824,12 +824,12 @@ begin
elsif strcmp(parameter^, "--parse\0".ptr) = 0 then
result^.parse := true
elsif parameter^^ <> '-' then
if result^.input <> nil then
write_s("Fatal error: Only one source file can be given.\n");
result := nil
else
if result^.input <> nil then
write_s("Fatal error: Only one source file can be given.\n");
result := nil
else
result^.input := parameter^
end
end
else
write_s("Fatal error: Unknown command line options: ");
@ -843,7 +843,7 @@ begin
end;
if result <> nil & result^.input = nil then
write_s("Fatal error: no input files.\n");
result := nil
result := nil
end;
return result
@ -863,151 +863,151 @@ begin
current_token := tokens + i;
case current_token^.kind of
TokenKind._if:
write_s("IF")
TokenKind._if:
write_s("IF")
| TokenKind._then:
write_s("THEN")
write_s("THEN")
| TokenKind._else:
write_s("ELSE")
write_s("ELSE")
| TokenKind._elsif:
write_s("ELSIF")
write_s("ELSIF")
| TokenKind._while:
write_s("WHILE")
write_s("WHILE")
| TokenKind._do:
write_s("DO")
| TokenKind._proc:
write_s("PROC")
| TokenKind._begin:
write_s("BEGIN")
| TokenKind._end:
write_s("END")
| TokenKind._extern:
write_s("EXTERN")
| TokenKind._const:
write_s("CONST")
| TokenKind._var:
write_s("VAR")
| TokenKind._case:
write_s("CASE")
| TokenKind._of:
write_s("OF")
| TokenKind._type:
write_s("TYPE")
| TokenKind._record:
write_s("RECORD")
| TokenKind._union:
write_s("UNION")
| TokenKind.pipe:
write_s("|")
| TokenKind.to:
write_s("TO")
| TokenKind.boolean:
write_s("BOOLEAN<");
write_b(current_token^.value.boolean_value);
write_c('>')
| TokenKind.null:
write_s("NIL")
| TokenKind.and:
write_s("&")
| TokenKind._or:
write_s("OR")
| TokenKind.not:
write_s("~")
| TokenKind._return:
write_s("RETURN")
| TokenKind._cast:
write_s("CAST")
| TokenKind.shift_left:
write_s("<<")
| TokenKind.shift_right:
write_s(">>")
| TokenKind.identifier:
write_c('<');
write_s("DO")
| TokenKind._proc:
write_s("PROC")
| TokenKind._begin:
write_s("BEGIN")
| TokenKind._end:
write_s("END")
| TokenKind._extern:
write_s("EXTERN")
| TokenKind._const:
write_s("CONST")
| TokenKind._var:
write_s("VAR")
| TokenKind._case:
write_s("CASE")
| TokenKind._of:
write_s("OF")
| TokenKind._type:
write_s("TYPE")
| TokenKind._record:
write_s("RECORD")
| TokenKind._union:
write_s("UNION")
| TokenKind.pipe:
write_s("|")
| TokenKind.to:
write_s("TO")
| TokenKind.boolean:
write_s("BOOLEAN<");
write_b(current_token^.value.boolean_value);
write_c('>')
| TokenKind.null:
write_s("NIL")
| TokenKind.and:
write_s("&")
| TokenKind._or:
write_s("OR")
| TokenKind.not:
write_s("~")
| TokenKind._return:
write_s("RETURN")
| TokenKind._cast:
write_s("CAST")
| TokenKind.shift_left:
write_s("<<")
| TokenKind.shift_right:
write_s(">>")
| TokenKind.identifier:
write_c('<');
write_s(current_token^.value.string);
write_c('>')
| TokenKind.trait:
write_c('#');
write_s(current_token^.value.string)
| TokenKind.left_paren:
write_s("(")
| TokenKind.right_paren:
write_s(")")
| TokenKind.left_square:
write_s("[")
| TokenKind.right_square:
write_s("]")
| TokenKind.greater_equal:
write_s(">=")
| TokenKind.less_equal:
write_s("<=")
| TokenKind.greater_than:
write_s(">")
| TokenKind.less_than:
write_s("<")
| TokenKind.equal:
write_s("=")
| TokenKind.not_equal:
write_s("<>")
| TokenKind.semicolon:
write_c(';')
| TokenKind.dot:
write_c('.')
| TokenKind.comma:
write_c(',')
| TokenKind.plus:
write_c('+')
| TokenKind.minus:
write_c('-')
| TokenKind.multiplication:
write_c('*')
| TokenKind.division:
write_c('/')
| TokenKind.remainder:
write_c('%')
| TokenKind.assignment:
write_s(":=")
| TokenKind.colon:
write_c(':')
| TokenKind.hat:
write_c('^')
| TokenKind.at:
write_c('@')
| TokenKind.comment:
write_s("(* COMMENT *)")
| TokenKind.integer:
write_c('<');
write_c('>')
| TokenKind.trait:
write_c('#');
write_s(current_token^.value.string)
| TokenKind.left_paren:
write_s("(")
| TokenKind.right_paren:
write_s(")")
| TokenKind.left_square:
write_s("[")
| TokenKind.right_square:
write_s("]")
| TokenKind.greater_equal:
write_s(">=")
| TokenKind.less_equal:
write_s("<=")
| TokenKind.greater_than:
write_s(">")
| TokenKind.less_than:
write_s("<")
| TokenKind.equal:
write_s("=")
| TokenKind.not_equal:
write_s("<>")
| TokenKind.semicolon:
write_c(';')
| TokenKind.dot:
write_c('.')
| TokenKind.comma:
write_c(',')
| TokenKind.plus:
write_c('+')
| TokenKind.minus:
write_c('-')
| TokenKind.multiplication:
write_c('*')
| TokenKind.division:
write_c('/')
| TokenKind.remainder:
write_c('%')
| TokenKind.assignment:
write_s(":=")
| TokenKind.colon:
write_c(':')
| TokenKind.hat:
write_c('^')
| TokenKind.at:
write_c('@')
| TokenKind.comment:
write_s("(* COMMENT *)")
| TokenKind.integer:
write_c('<');
write_i(current_token^.value.int_value);
write_c('>')
| TokenKind.word:
write_c('<');
write_c('>')
| TokenKind.word:
write_c('<');
write_i(current_token^.value.int_value);
write_s("u>")
| TokenKind.character:
write_c('<');
write_s("u>")
| TokenKind.character:
write_c('<');
write_i(cast(current_token^.value.char_value: Int));
write_s("c>")
| TokenKind.string:
write_s("\"...\"")
| TokenKind._defer:
write_s("DEFER")
| TokenKind.exclamation:
write_c('!')
| TokenKind.arrow:
write_s("->")
| TokenKind._program:
write_s("PROGRAM")
| TokenKind._module:
write_s("MODULE")
| TokenKind._import:
write_s("IMPORT")
else
write_s("UNKNOWN<");
write_i(cast(current_token^.kind: Int));
write_c('>')
end;
write_c(' ');
write_s("c>")
| TokenKind.string:
write_s("\"...\"")
| TokenKind._defer:
write_s("DEFER")
| TokenKind.exclamation:
write_c('!')
| TokenKind.arrow:
write_s("->")
| TokenKind._program:
write_s("PROGRAM")
| TokenKind._module:
write_s("MODULE")
| TokenKind._import:
write_s("IMPORT")
else
write_s("UNKNOWN<");
write_i(cast(current_token^.kind: Int));
write_c('>')
end;
write_c(' ');
i := i + 1u
i := i + 1u
end;
write_c('\n')
end;
@ -1052,22 +1052,22 @@ begin
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
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;
fclose(source_file^.handle)
end;
source_code.position := TextLocation(1u, 1u);
source_code.input := cast(source_file: Pointer);
source_code.empty := source_file_empty;
source_code.head := source_file_head;
source_code.advance := source_file_advance;
source_code.position := TextLocation(1u, 1u);
source_code.input := cast(source_file: Pointer);
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;