aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorEugen Wissner <belka@caraus.de>2026-11-18 00:10:23 +0100
committerEugen Wissner <belka@caraus.de>2026-11-20 00:08:40 +0100
commitd4681529c20d5cb2630bfe09f4cf4c4ca4c98a23 (patch)
treed11bc100c2e35fe7ee8e84837d8e2826e4b8731e
parent9b4b13e0d9030bb21c86eea6c4ba00bf4d91f0a0 (diff)
downloadelna-cpp.tar.gz
Restrict pointer subtraction by typeHEADcpp
-rw-r--r--boot/type_check.cc27
-rw-r--r--gcc/gcc/elna-tree.cc9
-rw-r--r--source/elna/lexer.elna247
-rw-r--r--source/elna/parser.elna26
-rw-r--r--source/elna/source.elna136
-rw-r--r--source/main.elna33
-rw-r--r--source/sys/posix/stdio.elna3
-rw-r--r--source/sys/posix/stdlib.elna6
-rw-r--r--testsuite/fail_compilation/pointer_subtraction_mismatch.elna10
-rw-r--r--testsuite/runnable/pointer_subtraction.elna18
10 files changed, 381 insertions, 134 deletions
diff --git a/boot/type_check.cc b/boot/type_check.cc
index bebee9a..4e21791 100644
--- a/boot/type_check.cc
+++ b/boot/type_check.cc
@@ -423,13 +423,11 @@ namespace elna::boot
{
return rhs;
}
- const bool lhs_integral = is_integral_type(lhs);
-
- if (lhs_integral == is_integral_type(rhs))
+ if (const std::shared_ptr<pointer_type> pointer = lhs.get<pointer_type>())
{
- return std::nullopt;
+ return find_opaque_type(pointer->base);
}
- if (const auto pointer = (lhs_integral ? rhs : lhs).get<pointer_type>())
+ if (const std::shared_ptr<pointer_type> pointer = rhs.get<pointer_type>())
{
return find_opaque_type(pointer->base);
}
@@ -1544,9 +1542,22 @@ namespace elna::boot
|| (is_numeric_type(lhs_resolved) && lhs_resolved == rhs_resolved);
break;
case subtraction:
- valid = (is_any_pointer_type(lhs_resolved) && is_integral_type(rhs_resolved))
- || (is_any_pointer_type(lhs_resolved) && is_any_pointer_type(rhs_resolved))
- || (is_numeric_type(lhs_resolved) && lhs_resolved == rhs_resolved);
+ if (const std::shared_ptr<pointer_type> lhs_pointer = lhs_resolved.get<pointer_type>())
+ {
+ if (const std::shared_ptr<pointer_type> rhs_pointer = rhs_resolved.get<pointer_type>())
+ {
+ valid = resolve_underlying_type(lhs_pointer->base)
+ == resolve_underlying_type(rhs_pointer->base);
+ }
+ else
+ {
+ valid = is_integral_type(rhs_resolved);
+ }
+ }
+ else
+ {
+ valid = is_numeric_type(lhs_resolved) && lhs_resolved == rhs_resolved;
+ }
break;
case division:
case multiplication:
diff --git a/gcc/gcc/elna-tree.cc b/gcc/gcc/elna-tree.cc
index 9612ae2..afc809b 100644
--- a/gcc/gcc/elna-tree.cc
+++ b/gcc/gcc/elna-tree.cc
@@ -138,11 +138,14 @@ namespace elna::gcc
convert_expression = fold_build1(NEGATE_EXPR, size_type_node, convert_expression);
return fold_build2_loc(operation_location, POINTER_PLUS_EXPR, pointer_type, left, convert_expression);
}
- else if (POINTER_TYPE_P(left_type) && POINTER_TYPE_P(right_type) && left_type == right_type)
+ else if (POINTER_TYPE_P(left_type) && POINTER_TYPE_P(right_type))
{
- return fold_build2_loc(operation_location, POINTER_DIFF_EXPR, ptrdiff_type_node, left, right);
+ tree size_exp = pointer_stride(left_type, ptrdiff_type_node);
+ tree diff = fold_build2_loc(operation_location, POINTER_DIFF_EXPR, ptrdiff_type_node, left, right);
+
+ return fold_build2_loc(operation_location, EXACT_DIV_EXPR, ptrdiff_type_node, diff, size_exp);
}
- return error_mark_node;
+ gcc_unreachable();
}
gcc_unreachable();
}
diff --git a/source/elna/lexer.elna b/source/elna/lexer.elna
index 9c83f06..14c54b2 100644
--- a/source/elna/lexer.elna
+++ b/source/elna/lexer.elna
@@ -1406,48 +1406,64 @@ begin
end
return result
-proc elna_lexer_token_dump_comment(token: ^ElnaLexerCommentToken; stream: ^FILE)
- if token^.content.length > 6u then
- fprintf(stream, "--%.*s…%.*s\0".ptr, 3, token^.content.ptr, 3, token^.content.ptr + token^.content.length - 3u)
+proc elna_lexer_dump_short_string(full_string: StdString; writer: ^ElnaSourceWriter)
+ if full_string.length > 6u then
+ writer^.sink^(writer, full_string[1 to 3]);
+ writer^.sink^(writer, "…");
+ writer^.sink^(writer, full_string[full_string.length - 2u to full_string.length])
else
- fprintf(stream, "--%.*s\0".ptr, token^.content.length, token^.content.ptr)
+ writer^.sink^(writer, full_string)
end
return
-proc elna_lexer_token_dump_docblock(token: ^ElnaLexerCommentToken; stream: ^FILE)
- if token^.content.length > 6u then
- fprintf(stream, "(*%.*s…%.*s*)\0".ptr, 3, token^.content.ptr,
- 3, token^.content.ptr + token^.content.length - 3u)
+proc elna_lexer_comment_token_dump_comment(token: ^ElnaLexerCommentToken; writer: ^ElnaSourceWriter)
+ writer^.sink^(writer, "--");
+ elna_lexer_dump_short_string(token^.content, writer)
+return
+
+proc elna_lexer_comment_token_dump_docblock(token: ^ElnaLexerCommentToken; writer: ^ElnaSourceWriter)
+ writer^.sink^(writer, "(*");
+ elna_lexer_dump_short_string(token^.content, writer);
+ writer^.sink^(writer, "*)")
+return
+
+proc elna_lexer_dump_byte(byte: Word8; writer: ^ElnaSourceWriter)
+ if byte = '\f' then
+ writer^.sink^(writer, "\\f")
+ elsif byte = '\v' then
+ writer^.sink^(writer, "\\v")
+ elsif byte = '\\' then
+ writer^.sink^(writer, "\\\\")
+ elsif byte = '"' then
+ writer^.sink^(writer, "\\\"")
+ elsif byte = '\0' then
+ writer^.sink^(writer, "\\0")
+ elsif byte = '\n' or byte = '\t' or byte = '\r' then
+ elna_source_writer_b(writer, byte)
+ elsif byte < 0x10u8 then
+ writer^.sink^(writer, "\\x0");
+ elna_source_writer_u(writer, cast(byte: Word), 16)
+ elsif byte < 32u8 or byte = 127u8 then
+ writer^.sink^(writer, "\\x");
+ elna_source_writer_u(writer, cast(byte: Word), 16)
else
- fprintf(stream, "(*%.*s*)\0".ptr, token^.content.length, token^.content.ptr)
+ elna_source_writer_b(writer, byte)
end
return
-proc elna_lexer_dump_string(token: ^ElnaLexerStringToken; stream: ^FILE)
- fputc(cast('"': CInt), stream);
+-- TODO: Do not print the whole string, but only the first and last 3
+-- characters.
+proc elna_lexer_string_token_dump(token: ^ElnaLexerStringToken; writer: ^ElnaSourceWriter)
+ elna_source_writer_b(writer, '"');
+
for c of token^.string do
- if c^ = '\f' then
- fprintf(stream, "\\f\0".ptr)
- elsif c^ = '\v' then
- fprintf(stream, "\\v\0".ptr)
- elsif c^ = '\\' then
- fprintf(stream, "\\\\\0".ptr)
- elsif c^ = '"' then
- fprintf(stream, "\\\"\0".ptr)
- elsif c^ = '\0' then
- fprintf(stream, "\\0\0".ptr)
- elsif c^ = '\n' or c^ = '\t' or c^ = '\r' then
- fputc(cast(c^: CInt), stream)
- elsif c^ < 32u8 or c^ = 127u8 then
- fprintf(stream, "\\x%02X\0".ptr, c^)
- else
- fputc(cast(c^: CInt), stream)
- end
+ elna_lexer_dump_byte(c^, writer)
end;
- fputc(cast('"': CInt), stream)
+ elna_source_writer_b(writer, '"')
return
-proc elna_lexer_dump_integer(token: ^ElnaLexerIntegerToken; stream: ^FILE)
+-- TODO: Migrate to ElnaSourceWriter.
+proc elna_lexer_integer_dump(token: ^ElnaLexerIntegerToken; stream: ^FILE; writer: ^ElnaSourceWriter)
if token^.is_signed then
if token^.size = 0u8 then
fprintf(stream, "«%lld»\0".ptr, token^.magnitude)
@@ -1455,107 +1471,108 @@ proc elna_lexer_dump_integer(token: ^ElnaLexerIntegerToken; stream: ^FILE)
fprintf(stream, "«%lldi%d»\0".ptr, token^.magnitude, token^.size)
end
else
- if token^.size = 0u8 then
- fprintf(stream, "«0x%Xu»\0".ptr, token^.magnitude)
- else
- fprintf(stream, "«0x%Xu%d»\0".ptr, token^.magnitude, token^.size)
+ writer^.sink^(writer, "0x");
+ elna_source_writer_lu(writer, token^.magnitude, 16);
+ elna_source_writer_b(writer, 'u');
+
+ if token^.size <> 0u8 then
+ elna_source_writer_u(writer, cast(token^.size: Word), 10)
end
end
return
-proc elna_lexer_token_dump*(token: ^ElnaLexerToken; stream: ^FILE)
+-- TODO: Migrate from stream to writer.
+-- TODO: Add a docblock.
+proc elna_lexer_token_dump*(token: ^ElnaLexerToken; stream: ^FILE; writer: ^ElnaSourceWriter)
fprintf(stream, "⟨\0".ptr);
case token^.kind of
- ElnaLexerTokenKind.comment: elna_lexer_token_dump_comment(cast(token: ^ElnaLexerCommentToken), stream) |
- ElnaLexerTokenKind.docblock: elna_lexer_token_dump_docblock(cast(token: ^ElnaLexerCommentToken), stream) |
- ElnaLexerTokenKind.if_: fprintf(stream, "«if»\0".ptr) |
- ElnaLexerTokenKind.then_: fprintf(stream, "«then»\0".ptr) |
- ElnaLexerTokenKind.else_: fprintf(stream, "«else»\0".ptr) |
- ElnaLexerTokenKind.elsif_: fprintf(stream, "«elsif»\0".ptr) |
- ElnaLexerTokenKind.while_: fprintf(stream, "«while»\0".ptr) |
- ElnaLexerTokenKind.for_: fprintf(stream, "«for»\0".ptr) |
- ElnaLexerTokenKind.repeat_: fprintf(stream, "«repeat»\0".ptr) |
- ElnaLexerTokenKind.until_: fprintf(stream, "«until»\0".ptr) |
- ElnaLexerTokenKind.with_: fprintf(stream, "«with»\0".ptr) |
- ElnaLexerTokenKind.do_: fprintf(stream, "«do»\0".ptr) |
- ElnaLexerTokenKind.proc_: fprintf(stream, "«proc»\0".ptr) |
- ElnaLexerTokenKind.begin_: fprintf(stream, "«begin»\0".ptr) |
- ElnaLexerTokenKind.end_: fprintf(stream, "«end»\0".ptr) |
- ElnaLexerTokenKind.extern_: fprintf(stream, "«extern»\0".ptr) |
- ElnaLexerTokenKind.const_: fprintf(stream, "«const»\0".ptr) |
- ElnaLexerTokenKind.var_: fprintf(stream, "«var»\0".ptr) |
- ElnaLexerTokenKind.threadvar_: fprintf(stream, "«threadvar»\0".ptr) |
- ElnaLexerTokenKind.type_: fprintf(stream, "«type»\0".ptr) |
- ElnaLexerTokenKind.record_: fprintf(stream, "«record»\0".ptr) |
- ElnaLexerTokenKind.true_: fprintf(stream, "«true»\0".ptr) |
- ElnaLexerTokenKind.false_: fprintf(stream, "«false»\0".ptr) |
- ElnaLexerTokenKind.and: fprintf(stream, "«&»\0".ptr) |
- ElnaLexerTokenKind.xor_: fprintf(stream, "«xor»\0".ptr) |
- ElnaLexerTokenKind.or_: fprintf(stream, "«or»\0".ptr) |
- ElnaLexerTokenKind.pipe: fprintf(stream, "«|»\0".ptr) |
- ElnaLexerTokenKind.not: fprintf(stream, "«~»\0".ptr) |
- ElnaLexerTokenKind.return_: fprintf(stream, "«return»\0".ptr) |
- ElnaLexerTokenKind.import_: fprintf(stream, "«import»\0".ptr) |
- ElnaLexerTokenKind.cast_: fprintf(stream, "«cast»\0".ptr) |
- ElnaLexerTokenKind.defer_: fprintf(stream, "«defer»\0".ptr) |
- ElnaLexerTokenKind.block_: fprintf(stream, "«block»\0".ptr) |
- ElnaLexerTokenKind.break_: fprintf(stream, "«break»\0".ptr) |
- ElnaLexerTokenKind.case_: fprintf(stream, "«case»\0".ptr) |
- ElnaLexerTokenKind.of_: fprintf(stream, "«of»\0".ptr) |
- ElnaLexerTokenKind.to_: fprintf(stream, "«to»\0".ptr) |
- ElnaLexerTokenKind.program_: fprintf(stream, "«program»\0".ptr) |
- ElnaLexerTokenKind.module_: fprintf(stream, "«module»\0".ptr) |
+ ElnaLexerTokenKind.comment:
+ elna_lexer_comment_token_dump_comment(cast(token: ^ElnaLexerCommentToken), writer) |
+ ElnaLexerTokenKind.docblock:
+ elna_lexer_comment_token_dump_docblock(cast(token: ^ElnaLexerCommentToken), writer) |
+ ElnaLexerTokenKind.if_: writer^.sink^(writer, "«if»\0") |
+ ElnaLexerTokenKind.then_: writer^.sink^(writer, "«then»") |
+ ElnaLexerTokenKind.else_: writer^.sink^(writer, "«else»") |
+ ElnaLexerTokenKind.elsif_: writer^.sink^(writer, "«elsif»") |
+ ElnaLexerTokenKind.while_: writer^.sink^(writer, "«while»") |
+ ElnaLexerTokenKind.for_: writer^.sink^(writer, "«for»") |
+ ElnaLexerTokenKind.repeat_: writer^.sink^(writer, "«repeat»") |
+ ElnaLexerTokenKind.until_: writer^.sink^(writer, "«until»") |
+ ElnaLexerTokenKind.with_: writer^.sink^(writer, "«with»") |
+ ElnaLexerTokenKind.do_: writer^.sink^(writer, "«do»") |
+ ElnaLexerTokenKind.proc_: writer^.sink^(writer, "«proc»") |
+ ElnaLexerTokenKind.begin_: writer^.sink^(writer, "«begin»") |
+ ElnaLexerTokenKind.end_: writer^.sink^(writer, "«end»") |
+ ElnaLexerTokenKind.extern_: writer^.sink^(writer, "«extern»") |
+ ElnaLexerTokenKind.const_: writer^.sink^(writer, "«const»") |
+ ElnaLexerTokenKind.var_: writer^.sink^(writer, "«var»") |
+ ElnaLexerTokenKind.threadvar_: writer^.sink^(writer, "«threadvar»") |
+ ElnaLexerTokenKind.type_: writer^.sink^(writer, "«type»") |
+ ElnaLexerTokenKind.record_: writer^.sink^(writer, "«record»") |
+ ElnaLexerTokenKind.true_: writer^.sink^(writer, "«true»") |
+ ElnaLexerTokenKind.false_: writer^.sink^(writer, "«false»") |
+ ElnaLexerTokenKind.and: writer^.sink^(writer, "«&»") |
+ ElnaLexerTokenKind.xor_: writer^.sink^(writer, "«xor»") |
+ ElnaLexerTokenKind.or_: writer^.sink^(writer, "«or»") |
+ ElnaLexerTokenKind.pipe: writer^.sink^(writer, "«|»") |
+ ElnaLexerTokenKind.not: writer^.sink^(writer, "«~»") |
+ ElnaLexerTokenKind.return_: writer^.sink^(writer, "«return»") |
+ ElnaLexerTokenKind.import_: writer^.sink^(writer, "«import»") |
+ ElnaLexerTokenKind.cast_: writer^.sink^(writer, "«cast»") |
+ ElnaLexerTokenKind.defer_: writer^.sink^(writer, "«defer»") |
+ ElnaLexerTokenKind.block_: writer^.sink^(writer, "«block»") |
+ ElnaLexerTokenKind.break_: writer^.sink^(writer, "«break»") |
+ ElnaLexerTokenKind.case_: writer^.sink^(writer, "«case»") |
+ ElnaLexerTokenKind.of_: writer^.sink^(writer, "«of»") |
+ ElnaLexerTokenKind.to_: writer^.sink^(writer, "«to»") |
+ ElnaLexerTokenKind.program_: writer^.sink^(writer, "«program»") |
+ ElnaLexerTokenKind.module_: writer^.sink^(writer, "«module»") |
ElnaLexerTokenKind.identifier:
- var
- identifier := cast(token: ^ElnaLexerIdentifierToken)^.identifier
- begin
- fprintf(stream, "Identifier «%.*s»\0".ptr, identifier.length, identifier.ptr)
- |
+ writer^.sink^(writer, cast(token: ^ElnaLexerIdentifierToken)^.identifier) |
ElnaLexerTokenKind.trait:
- var
- identifier := cast(token: ^ElnaLexerIdentifierToken)^.identifier
- begin
- fprintf(stream, "#%.*s\0".ptr, identifier.length, identifier.ptr)
+ writer^.sink^(writer, "#");
+ writer^.sink^(writer, cast(token: ^ElnaLexerIdentifierToken)^.identifier)
|
- ElnaLexerTokenKind.generic_open: fprintf(stream, "«#[»\0".ptr) |
- ElnaLexerTokenKind.attribute_open: fprintf(stream, "«#{»\0".ptr) |
- ElnaLexerTokenKind.integer: elna_lexer_dump_integer(cast(token: ^ElnaLexerIntegerToken), stream) |
+ ElnaLexerTokenKind.generic_open: writer^.sink^(writer, "«#[»") |
+ ElnaLexerTokenKind.attribute_open: writer^.sink^(writer, "«#{»") |
+ ElnaLexerTokenKind.integer: elna_lexer_integer_dump(cast(token: ^ElnaLexerIntegerToken), stream, writer) |
ElnaLexerTokenKind.double:
fprintf(stream, "«%g»\0".ptr, cast(token: ^ElnaLexerFloatToken)^.value) |
ElnaLexerTokenKind.single:
fprintf(stream, "«%gf»\0".ptr, cast(token: ^ElnaLexerFloatToken)^.value) |
ElnaLexerTokenKind.character:
fprintf(stream, "\\{U+%X}\0".ptr, cast(token: ^ElnaLexerCharacterToken)^.codepoint) |
- ElnaLexerTokenKind.string: elna_lexer_dump_string(cast(token: ^ElnaLexerStringToken), stream) |
- ElnaLexerTokenKind.left_paren: fprintf(stream, "«(»\0".ptr) |
- ElnaLexerTokenKind.right_paren: fprintf(stream, "«)»\0".ptr) |
- ElnaLexerTokenKind.left_square: fprintf(stream, "«[»\0".ptr) |
- ElnaLexerTokenKind.right_square: fprintf(stream, "«]»\0".ptr) |
- ElnaLexerTokenKind.left_brace: fprintf(stream, "«{»\0".ptr) |
- ElnaLexerTokenKind.right_brace: fprintf(stream, "«}»\0".ptr) |
- ElnaLexerTokenKind.shift_left: fprintf(stream, "«<<»\0".ptr) |
- ElnaLexerTokenKind.shift_right: fprintf(stream, "«>>»\0".ptr) |
- ElnaLexerTokenKind.greater_equal: fprintf(stream, "«>=»\0".ptr) |
- ElnaLexerTokenKind.less_equal: fprintf(stream, "«<=»\0".ptr) |
- ElnaLexerTokenKind.greater_than: fprintf(stream, "«>»\0".ptr) |
- ElnaLexerTokenKind.less_than: fprintf(stream, "«<»\0".ptr) |
- ElnaLexerTokenKind.not_equal: fprintf(stream, "«<>»\0".ptr) |
- ElnaLexerTokenKind.equals: fprintf(stream, "«=»\0".ptr) |
- ElnaLexerTokenKind.semicolon: fprintf(stream, "«;»\0".ptr) |
- ElnaLexerTokenKind.dot: fprintf(stream, "«.»\0".ptr) |
- ElnaLexerTokenKind.comma: fprintf(stream, "«,»\0".ptr) |
- ElnaLexerTokenKind.plus: fprintf(stream, "«+»\0".ptr) |
- ElnaLexerTokenKind.minus: fprintf(stream, "«-»\0".ptr) |
- ElnaLexerTokenKind.multiplication: fprintf(stream, "«*»\0".ptr) |
- ElnaLexerTokenKind.division: fprintf(stream, "«/»\0".ptr) |
- ElnaLexerTokenKind.remainder: fprintf(stream, "«%»\0".ptr) |
- ElnaLexerTokenKind.assignment: fprintf(stream, "«:=»\0".ptr) |
- ElnaLexerTokenKind.colon: fprintf(stream, "«:»\0".ptr) |
- ElnaLexerTokenKind.hat: fprintf(stream, "«^»\0".ptr) |
- ElnaLexerTokenKind.at: fprintf(stream, "«@»\0".ptr) |
- ElnaLexerTokenKind.arrow: fprintf(stream, "«->»\0".ptr) |
- ElnaLexerTokenKind.eof: fprintf(stream, "EOF\0".ptr)
+ ElnaLexerTokenKind.string:
+ elna_lexer_string_token_dump(cast(token: ^ElnaLexerStringToken), writer) |
+ ElnaLexerTokenKind.left_paren: writer^.sink^(writer, "«(»") |
+ ElnaLexerTokenKind.right_paren: writer^.sink^(writer, "«)»") |
+ ElnaLexerTokenKind.left_square: writer^.sink^(writer, "«[»") |
+ ElnaLexerTokenKind.right_square: writer^.sink^(writer, "«]»") |
+ ElnaLexerTokenKind.left_brace: writer^.sink^(writer, "«{»") |
+ ElnaLexerTokenKind.right_brace: writer^.sink^(writer, "«}»") |
+ ElnaLexerTokenKind.shift_left: writer^.sink^(writer, "«<<»") |
+ ElnaLexerTokenKind.shift_right: writer^.sink^(writer, "«>>»") |
+ ElnaLexerTokenKind.greater_equal: writer^.sink^(writer, "«>=»") |
+ ElnaLexerTokenKind.less_equal: writer^.sink^(writer, "«<=»") |
+ ElnaLexerTokenKind.greater_than: writer^.sink^(writer, "«>»") |
+ ElnaLexerTokenKind.less_than: writer^.sink^(writer, "«<»") |
+ ElnaLexerTokenKind.not_equal: writer^.sink^(writer, "«<>»") |
+ ElnaLexerTokenKind.equals: writer^.sink^(writer, "«=»") |
+ ElnaLexerTokenKind.semicolon: writer^.sink^(writer, "«;»") |
+ ElnaLexerTokenKind.dot: writer^.sink^(writer, "«.»") |
+ ElnaLexerTokenKind.comma: writer^.sink^(writer, "«,»") |
+ ElnaLexerTokenKind.plus: writer^.sink^(writer, "«+»") |
+ ElnaLexerTokenKind.minus: writer^.sink^(writer, "«-»") |
+ ElnaLexerTokenKind.multiplication: writer^.sink^(writer, "«*»") |
+ ElnaLexerTokenKind.division: writer^.sink^(writer, "«/»") |
+ ElnaLexerTokenKind.remainder: writer^.sink^(writer, "«%»") |
+ ElnaLexerTokenKind.assignment: writer^.sink^(writer, "«:=»") |
+ ElnaLexerTokenKind.colon: writer^.sink^(writer, "«:»") |
+ ElnaLexerTokenKind.hat: writer^.sink^(writer, "«^»") |
+ ElnaLexerTokenKind.at: writer^.sink^(writer, "«@»") |
+ ElnaLexerTokenKind.arrow: writer^.sink^(writer, "«->»") |
+ ElnaLexerTokenKind.eof: writer^.sink^(writer, "EOF")
end;
fprintf(stream, "; Position: [%lu, %lu)⟩\n\0".ptr, token^.position.start_offset, token^.position.end_offset)
return
diff --git a/source/elna/parser.elna b/source/elna/parser.elna
index 0d7d7bd..78789e6 100644
--- a/source/elna/parser.elna
+++ b/source/elna/parser.elna
@@ -14,6 +14,10 @@ type
current: StdOptional#[ElnaLexerToken];
diagnostics: StdSList#[ElnaSourceDiagnostic]
end
+ ElnaParserDiagnosticCode = (unexpected_token = 100)
+ ElnaParserDiagnosticToken = record(ElnaSourceDiagnosticArgument)
+ token: ^ElnaLexerToken
+ end
proc elna_parser_make*(lexer: ^ElnaLexerCursor) -> ElnaParser
return { ElnaParser;
@@ -21,6 +25,15 @@ return { ElnaParser;
current: elna_lexer_lex(lexer)
}
+-- TODO: Dump real token.
+proc elna_parser_diagnostic_token_format(self: ^ElnaSourceDiagnosticArgument; output: ^ElnaSourceWriter)
+ output^.sink^(output, "'token'")
+return
+
+-- TODO: Free parsed nodes.
+-- TODO: Destroy tokens.
+-- TODO: Free diagnostic errors.
+-- TODO: Save expected and actual tokens in the error.
proc elna_parser_program*(parser: ^ElnaParser) -> ^ElnaAstUnit
var
unit := malloc#[ElnaAstUnit](#size(ElnaAstUnit))
@@ -33,7 +46,20 @@ begin
else
var
error := malloc#[ElnaSourceDiagnostic](#size(ElnaSourceDiagnostic))
+ error_argument := malloc#[ElnaParserDiagnosticToken](#size(ElnaParserDiagnosticToken))
+ error_arguments := malloc#[^ElnaSourceDiagnosticArgument](#size(^ElnaSourceDiagnosticArgument) * 2u)[1 to 2]
begin
+ error_argument^ := { ElnaParserDiagnosticToken;
+ format: @elna_parser_diagnostic_token_format,
+ token: parser^.current.value
+ };
+ error_arguments[1] := error_argument;
+ error_arguments[2] := error_argument;
+ error^ := { ElnaSourceDiagnostic;
+ code: cast(ElnaParserDiagnosticCode.unexpected_token: Word),
+ format: "Unexpected token %1, expected %2.\0",
+ arguments: error_arguments
+ };
std_slist_append(@parser^.diagnostics, error)
end
end
diff --git a/source/elna/source.elna b/source/elna/source.elna
index 399701e..ef5d1b9 100644
--- a/source/elna/source.elna
+++ b/source/elna/source.elna
@@ -5,13 +5,147 @@
(* Source code representation. *)
module
+import sys.ffi, sys.posix.stdio, sys.posix.stdlib, std
+
type
+ (* Spans a range in the source code from a start to an end position. *)
ElnaSourceSpan* = record
start_offset: Word;
end_offset: Word
end
+ (* Interface for printing some buffer. *)
+ ElnaSourceWriter* = record
+ sink: ^proc(context: ^ElnaSourceWriter; buffer: StdString)
+ end
+ (* Context for Unix stream writer. *)
+ ElnaSourceStdioWriter* = record(ElnaSourceWriter)
+ stream: ^FILE
+ end
+ (* Argument for the diagnostic message formatting. *)
+ ElnaSourceDiagnosticArgument* = record
+ format: ^proc(self: ^ElnaSourceDiagnosticArgument; output: ^ElnaSourceWriter)
+ end
+ (* Describes single diagnostic message. *)
ElnaSourceDiagnostic* = record
- code: Word
+ code: Word;
+ format: StdString;
+ arguments: []^ElnaSourceDiagnosticArgument
+ end
+
+(*
+ Writer implementation that writes a string buffer into a Unix stream.
+
+ @param context File writer context.
+ @param buffer String to write.
+*)
+proc elna_source_stdio_writer_sink*(self: ^ElnaSourceWriter; buffer: StdString)
+ fprintf(cast(self: ^ElnaSourceStdioWriter)^.stream,
+ "%.*s\0".ptr, buffer.length, buffer.ptr)
+return
+
+(*
+ Writes a byte.
+
+ @param self Writer.
+ @param byte Input byte.
+*)
+proc elna_source_writer_b*(self: ^ElnaSourceWriter; byte: Word8)
+ self^.sink^(self, (@byte)[1 to 1])
+return
+
+(*
+ Writes an unsigned integer.
+
+ The base parameter can be positive or negative. The sign only matters for
+ hexadecimal integers (base 16): positive base prints uppercase 'a' to 'f',
+ negative one — downcase.
+
+ @param self Writer.
+ @param base Positive or negative 2, 8, 10 or 16.
+*)
+proc elna_source_writer_u*(self: ^ElnaSourceWriter; integer: Word; base: Int) -> Bool
+const
+ BUFFER_SIZE = 65u
+var
+ written := cast(-1: CInt)
+ buffer: [BUFFER_SIZE]Word8
+ format := ""
+begin
+ case base of
+ 2, -2: format := "%zb\0" |
+ 8, -8: format := "%zo\0" |
+ 10, -10: format := "%zu\0" |
+ 16: format := "%zX\0" |
+ -16: format := "%zx\0"
+ end;
+ if format.length > 0u then
+ written := snprintf(cast(buffer.ptr: ^CChar), cast(BUFFER_SIZE: Word), format.ptr, integer);
+ self^.sink^(self, buffer[1 to cast(written: Int)])
+ end
+return written > cast(0: CInt) & written < cast(BUFFER_SIZE: CInt)
+
+(*
+ Writes an unsigned 64-bit integer.
+
+ The base parameter can be positive or negative. The sign only matters for
+ hexadecimal integers (base 16): positive base prints uppercase 'a' to 'f',
+ negative one — downcase.
+
+ @param self Writer.
+ @param base Positive or negative 2, 8, 10 or 16.
+*)
+proc elna_source_writer_lu*(self: ^ElnaSourceWriter; integer: Word64; base: Int) -> Bool
+const
+ BUFFER_SIZE = 65u
+var
+ written := cast(-1: CInt)
+ buffer: [BUFFER_SIZE]Word8
+ format := ""
+begin
+ case base of
+ 2, -2: format := "%llb\0" |
+ 8, -8: format := "%llo\0" |
+ 10, -10: format := "%llu\0" |
+ 16: format := "%llX\0" |
+ -16: format := "%llx\0"
+ end;
+ if format.length > 0u then
+ written := snprintf(cast(buffer.ptr: ^CChar), cast(BUFFER_SIZE: Word), format.ptr, integer);
+ self^.sink^(self, buffer[1 to cast(written: Int)])
end
+return written > cast(0: CInt) & written < cast(BUFFER_SIZE: CInt)
+
+(*
+ Writes single diagnostic message using the given writer.
+
+ @param self Diagnostic context.
+ @param writer Writer.
+*)
+proc elna_source_diagnostic_print*(self: ^ElnaSourceDiagnostic; writer: ^ElnaSourceWriter)
+var
+ format := self^.format
+ format_position := 1u
+begin
+ while format_position < format.length - 1u do
+ if format[format_position] = '%' then
+ var
+ format_end: ^CChar
+ format_index: CULong
+ begin
+ writer^.sink^(writer, format[1 to format_position - 1u]);
+ format := format[format_position + 1u to format.length];
+
+ format_index := strtoul(format.ptr, @format_end, cast(10: CInt));
+ format := format[cast(cast(format_end: ^Word8) - format.ptr: Word) + 1u to format.length];
+ format_position := 1u;
+
+ self^.arguments[format_index]^.format^(self^.arguments[format_index], writer)
+ else
+ format_position := format_position + 1u
+ end
+ end;
+ writer^.sink^(writer, format);
+ writer^.sink^(writer, "\n")
+return
end.
diff --git a/source/main.elna b/source/main.elna
index f6b213f..945e2e6 100644
--- a/source/main.elna
+++ b/source/main.elna
@@ -2,24 +2,43 @@
v. 2.0. If a copy of the MPL was not distributed with this file, You can
obtain one at https://mozilla.org/MPL/2.0/. *)
program()
-import sys.posix.stdio, std, elna.lexer, elna.ast, elna.parser
+import sys.ffi, sys.posix.stdio, sys.posix.stdlib, std,
+ elna.lexer, elna.ast, elna.parser, elna.source
var
- sample_source_text := "program() Here.a few (* documentation block *) or #size if '\\n' `У` \"некоторая строка\" 23 -- End line comment\0"
+ sample_source_text := "rogram() Here.a few (* documentation block *) or #size if '\\n' `У` \"некоторая строка\" 23 -- End line comment\0"
begin
elna_lexer_transitions();
block local_main
var
- global_cursor := elna_lexer_cursor_make(sample_source_text)
- parser := elna_parser_make(@global_cursor)
+ lexer_cursor := elna_lexer_cursor_make(sample_source_text)
+ parser := elna_parser_make(@lexer_cursor)
tree := elna_parser_program(@parser)
+ writer := { ElnaSourceStdioWriter; stream: stderr_(), sink: @elna_source_stdio_writer_sink }
begin
if std_slist_empty(@parser.diagnostics) then
- fputs("int main(){ return 0; }\n\0".ptr, stdout_())
+ fputs("int main(){ return 0; }\n\0".ptr, stdout_());
+
+ exit(cast(0: CInt))
else
- fputs("Parsing failed.\n\0".ptr, stderr_())
- end;
+ var
+ current_entry := parser.diagnostics.head.value
+ current_token := parser.current
+ begin
+ repeat
+ elna_source_diagnostic_print(current_entry^.value, @writer);
+
+ current_entry := current_entry^.next
+ until current_entry = parser.diagnostics.head.value;
+
+ while current_token.value^.kind <> ElnaLexerTokenKind.eof do
+ elna_lexer_token_dump(current_token.value, stderr_(), @writer);
+ current_token := elna_lexer_lex(@lexer_cursor)
+ end;
+
+ exit(cast(1: CInt))
+ end
end
end.
diff --git a/source/sys/posix/stdio.elna b/source/sys/posix/stdio.elna
index c667f43..3635b7c 100644
--- a/source/sys/posix/stdio.elna
+++ b/source/sys/posix/stdio.elna
@@ -11,6 +11,9 @@ extern
proc printf*(format: ^const CChar) #{varargs} -> CInt
extern
+proc snprintf*(str: ^CChar; size: Word; format: ^const CChar) #{varargs} -> CInt
+extern
+
proc fputs*(s: ^const CChar; stream: ^FILE) -> CInt
extern
diff --git a/source/sys/posix/stdlib.elna b/source/sys/posix/stdlib.elna
index 272400a..ce49155 100644
--- a/source/sys/posix/stdlib.elna
+++ b/source/sys/posix/stdlib.elna
@@ -32,4 +32,10 @@ extern
proc strtod*(nptr: ^const CChar; endptr: ^^CChar) -> Double
extern
+proc exit*(status: CInt) #{noreturn}
+extern
+
+proc sprintf*(str: ^CChar; format: ^const CChar) #{varargs} -> CInt
+extern
+
end.
diff --git a/testsuite/fail_compilation/pointer_subtraction_mismatch.elna b/testsuite/fail_compilation/pointer_subtraction_mismatch.elna
new file mode 100644
index 0000000..5ad1dcb
--- /dev/null
+++ b/testsuite/fail_compilation/pointer_subtraction_mismatch.elna
@@ -0,0 +1,10 @@
+program()
+
+var
+ p: ^Int
+ q: ^Word
+ diff: Int
+
+begin
+ diff := p - q (* @Error Invalid operands of type '\^Int' and '\^Word' for operator - *)
+end.
diff --git a/testsuite/runnable/pointer_subtraction.elna b/testsuite/runnable/pointer_subtraction.elna
new file mode 100644
index 0000000..41d45f6
--- /dev/null
+++ b/testsuite/runnable/pointer_subtraction.elna
@@ -0,0 +1,18 @@
+program()
+var
+ a: [4]Int
+ first: ^Int
+ third: ^Int
+ diff: Int
+ c: ^const Int
+ diff_const: Int
+
+begin
+ first := @a[1];
+ third := @a[3];
+ diff := third - first;
+ c := third;
+ diff_const := c - first;
+ assert(diff = 2);
+ assert(diff_const = 2)
+end.