aboutsummaryrefslogtreecommitdiff
path: root/source
diff options
context:
space:
mode:
Diffstat (limited to 'source')
-rw-r--r--source/elna/ast.elna21
-rw-r--r--source/elna/lexer.elna270
-rw-r--r--source/elna/parser.elna29
-rw-r--r--source/main.elna14
-rw-r--r--source/sys/posix/stdio.elna20
-rw-r--r--source/sys/posix/stdlib.elna15
-rw-r--r--source/sys/posix/string.elna6
7 files changed, 218 insertions, 157 deletions
diff --git a/source/elna/ast.elna b/source/elna/ast.elna
new file mode 100644
index 0000000..2fca087
--- /dev/null
+++ b/source/elna/ast.elna
@@ -0,0 +1,21 @@
+(* 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/. *)
+
+(* Abstract syntax tree representation. *)
+module
+
+import elna.source
+
+type
+ ElnaAstKind* = (
+ unit
+ )
+ ElnaAstNode* = record
+ kind: ElnaAstKind;
+ position: ElnaSourceSpan
+ end
+ ElnaAstUnit* = record(ElnaAstNode)
+ end
+
+end.
diff --git a/source/elna/lexer.elna b/source/elna/lexer.elna
index f7bb4f7..05dd1b2 100644
--- a/source/elna/lexer.elna
+++ b/source/elna/lexer.elna
@@ -6,7 +6,7 @@
module
import
- std, sys.posix.stdlib, sys.posix.string, sys.posix.stdio, sys.posix.errno,
+ std, sys.ffi, sys.posix.stdlib, sys.posix.string, sys.posix.stdio, sys.posix.errno,
elna.source
type
@@ -925,7 +925,7 @@ begin
hex_digits := [0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8]
begin
memcpy(hex_digits.ptr, digits_start, cast(current_position - digits_start: Word));
- codepoint := cast(strtoul(hex_digits.ptr, cast(0: ^^Word8), 16): Word32);
+ codepoint := cast(strtoul(hex_digits.ptr, cast(0: ^^CChar), cast(16: CInt)): Word32);
if (codepoint >= ELNA_LEXER_UTF8_SURROGATE_RANGE_START & codepoint <= ELNA_LEXER_UTF8_SURROGATE_RANGE_END)
or codepoint > ELNA_LEXER_UTF8_MAX_UNICODE_CODEPOINT then
@@ -948,7 +948,7 @@ begin
if elna_lexer_is_hex(current_position^) & elna_lexer_is_hex((current_position + 1)^) then
var
hex_digits: const := [current_position^, (current_position + 1)^, 0u8]
- character: const := cast(strtol(hex_digits.ptr, cast(0: ^^Word8), 16): Word8)
+ character: const := cast(strtol(hex_digits.ptr, cast(0: ^^CChar), cast(16: CInt)): Word8)
begin
output^^ := character;
output^ := output^ + 1;
@@ -1121,14 +1121,14 @@ begin
if number_string.length > 2u & number_string[1] = '0' & (number_string[2] = 'b' or number_string[2] = 'B') then
start := start + 2;
- integer_token.magnitude := strtoull(start, @number_stop, 2);
+ integer_token.magnitude := strtoull(start, @number_stop, cast(2: CInt));
is_prefixed := true
elsif number_string.length > 2u & number_string[1] = '0' & (number_string[2] = 'x' or number_string[2] = 'X') then
start := start + 2;
- integer_token.magnitude := strtoull(start, @number_stop, 16);
+ integer_token.magnitude := strtoull(start, @number_stop, cast(16: CInt));
is_prefixed := true
else
- integer_token.magnitude := strtoull(start, @number_stop, 10)
+ integer_token.magnitude := strtoull(start, @number_stop, cast(10: CInt))
end;
if number_stop > start & errno()^ <> ERANGE then
if cursor = number_stop then
@@ -1194,13 +1194,13 @@ return
Creates a token of the given kind. The created token is a simple token without
any payload.
*)
-proc elna_lexer_token_create(kind: ElnaLexerTokenKind) -> ^ElnaLexerToken
+proc elna_lexer_token_create(kind: ElnaLexerTokenKind) -> StdOptional#[ElnaLexerToken]
var
- result: ^ElnaLexerToken
+ plain_token: ^ElnaLexerToken
begin
- result := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
- result^.kind := kind
-return result
+ plain_token := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
+ plain_token^.kind := kind
+return std_optional_make(plain_token)
(*
Frees the memory allocated for the token itself and for its internal storage.
@@ -1229,9 +1229,9 @@ proc elna_lexer_token_destroy*(token: ^ElnaLexerToken)
free(token)
return
-proc elna_lexer_identify_keyword(start, cursor: ^const Word8) -> ^ElnaLexerToken
+proc elna_lexer_identify_keyword(start, cursor: ^const Word8) -> StdOptional#[ElnaLexerToken]
var
- result: ^ElnaLexerToken
+ result: StdOptional#[ElnaLexerToken]
identifier: StdString := start[1 to cursor - start]
begin
case identifier of
@@ -1278,11 +1278,11 @@ begin
identifier_token^.kind := ElnaLexerTokenKind.identifier;
identifier_token^.identifier := identifier_pointer[1 to identifier.length];
- result := identifier_token
+ result := std_optional_make#[ElnaLexerToken](identifier_token)
end
return result
-proc elna_lexer_identify_trait(start, cursor: ^const Word8) -> ^ElnaLexerToken
+proc elna_lexer_identify_trait(start, cursor: ^const Word8) -> StdOptional#[ElnaLexerToken]
var
identifier: StdString := start[2 to cursor - start]
result := malloc#[ElnaLexerIdentifierToken](#size(ElnaLexerIdentifierToken))
@@ -1292,11 +1292,11 @@ begin
result^.kind := ElnaLexerTokenKind.trait;
result^.identifier := identifier_pointer[1 to identifier.length]
-return result
+return std_optional_make#[ElnaLexerToken](result)
-proc elna_lexer_stop_single(start: ^const Word8) -> ^ElnaLexerToken
+proc elna_lexer_stop_single(start: ^const Word8) -> StdOptional#[ElnaLexerToken]
var
- result: ^ElnaLexerToken
+ result: StdOptional#[ElnaLexerToken]
begin
case start^ of
'&': result := elna_lexer_token_create(ElnaLexerTokenKind.and) |
@@ -1322,7 +1322,7 @@ begin
end
return result
-proc elna_lexer_stop_comment(kind: ElnaLexerTokenKind; start, cursor: ^const Word8) -> ^ElnaLexerCommentToken
+proc elna_lexer_stop_comment(kind: ElnaLexerTokenKind; start, cursor: ^const Word8) -> StdOptional#[ElnaLexerToken]
var
comment_token := malloc#[ElnaLexerCommentToken](#size(ElnaLexerCommentToken))
comment_start: ^const Word8 := start + 2u
@@ -1332,17 +1332,14 @@ begin
comment_token^.kind := kind;
memcpy(comment_pointer, comment_start, comment_length);
comment_token^.content := comment_pointer[1 to comment_length]
-return comment_token
+return std_optional_make#[ElnaLexerToken](comment_token)
proc elna_lexer_delimit_string(start, cursor: ^const Word8) -> StdOptional#[ElnaLexerToken]
var
result := { StdOptional#[ElnaLexerToken] }
begin
if start^ = '(' then
- var
- comment_token := elna_lexer_stop_comment(ElnaLexerTokenKind.docblock, start, cursor - 2)
- begin
- result := std_optional_make#[ElnaLexerToken](comment_token)
+ result := elna_lexer_stop_comment(ElnaLexerTokenKind.docblock, start, cursor - 2)
elsif start^ = '\'' then
result := elna_lexer_parse_byte_literal(start)
elsif start^ = '`' then
@@ -1352,17 +1349,15 @@ begin
end
return result
--- TODO: Return type should be "error or a pointer".
--- TODO: Save the position in the token.
-proc elna_lexer_lex*(cursor: ^ElnaLexerCursor) -> ^ElnaLexerToken
+proc elna_lexer_lex*(cursor: ^ElnaLexerCursor) -> StdOptional#[ElnaLexerToken]
var
- result: ^ElnaLexerToken := cast(0: ^ElnaLexerToken)
+ result := { StdOptional#[ElnaLexerToken] }
begin
elna_lexer_skip_trivia(cursor);
case cursor^.state of
ElnaLexerState.stop:
- result := elna_lexer_delimit_string(cursor^.start, cursor^.cursor).value
+ result := elna_lexer_delimit_string(cursor^.start, cursor^.cursor)
|
ElnaLexerState.comment:
result := elna_lexer_stop_comment(ElnaLexerTokenKind.comment, cursor^.start, cursor^.cursor)
@@ -1370,12 +1365,12 @@ begin
ElnaLexerState.leading_zero,
ElnaLexerState.integer,
ElnaLexerState.integer_tail:
- result := elna_lexer_parse_integer(cursor^.start, cursor^.cursor).value
+ result := elna_lexer_parse_integer(cursor^.start, cursor^.cursor)
|
ElnaLexerState.float_tail,
ElnaLexerState.exponent,
ElnaLexerState.fraction:
- result := elna_lexer_parse_float(cursor^.start, cursor^.cursor).value
+ result := elna_lexer_parse_float(cursor^.start, cursor^.cursor)
|
ElnaLexerState.identifier: result := elna_lexer_identify_keyword(cursor^.start, cursor^.cursor) |
ElnaLexerState.single: result := elna_lexer_stop_single(cursor^.start) |
@@ -1395,166 +1390,167 @@ begin
ElnaLexerState.less: result := elna_lexer_token_create(ElnaLexerTokenKind.less_than) |
ElnaLexerState.trait: result := elna_lexer_identify_trait(cursor^.start, cursor^.cursor) |
ElnaLexerState.eof: result := elna_lexer_token_create(ElnaLexerTokenKind.eof)
- else
- result := malloc#[ElnaLexerToken](#size(ElnaLexerToken));
- memset(result, 0, #size(ElnaLexerToken))
+ end;
+ if result.has_value then
+ result.value^.position := { ElnaSourceSpan;
+ start_offset: cursor^.position,
+ end_offset: cursor^.position + cast(cursor^.cursor - cursor^.start: Word)
+ }
end
return result
-proc elna_lexer_token_dump_comment(token: ^ElnaLexerCommentToken)
+proc elna_lexer_token_dump_comment(token: ^ElnaLexerCommentToken; stream: ^FILE)
if token^.content.length > 6u then
- printf("--%.*s…%.*s\0".ptr, 3, token^.content.ptr, 3, token^.content.ptr + token^.content.length - 3u)
+ fprintf(stream, "--%.*s…%.*s\0".ptr, 3, token^.content.ptr, 3, token^.content.ptr + token^.content.length - 3u)
else
- printf("--%.*s\0".ptr, token^.content.length, token^.content.ptr)
+ fprintf(stream, "--%.*s\0".ptr, token^.content.length, token^.content.ptr)
end
return
-proc elna_lexer_token_dump_docblock(token: ^ElnaLexerCommentToken)
+proc elna_lexer_token_dump_docblock(token: ^ElnaLexerCommentToken; stream: ^FILE)
if token^.content.length > 6u then
- printf("(*%.*s…%.*s*)\0".ptr, 3, token^.content.ptr,
+ fprintf(stream, "(*%.*s…%.*s*)\0".ptr, 3, token^.content.ptr,
3, token^.content.ptr + token^.content.length - 3u)
else
- printf("(*%.*s*)\0".ptr, token^.content.length, token^.content.ptr)
+ fprintf(stream, "(*%.*s*)\0".ptr, token^.content.length, token^.content.ptr)
end
return
-proc elna_lexer_dump_string(token: ^ElnaLexerStringToken)
- putchar(cast('"': Int));
+proc elna_lexer_dump_string(token: ^ElnaLexerStringToken; stream: ^FILE)
+ fputc(cast('"': CInt), stream);
for c of token^.string do
if c^ = '\f' then
- printf("\\f\0".ptr)
+ fprintf(stream, "\\f\0".ptr)
elsif c^ = '\v' then
- printf("\\v\0".ptr)
+ fprintf(stream, "\\v\0".ptr)
elsif c^ = '\\' then
- printf("\\\\\0".ptr)
+ fprintf(stream, "\\\\\0".ptr)
elsif c^ = '"' then
- printf("\\\"\0".ptr)
+ fprintf(stream, "\\\"\0".ptr)
elsif c^ = '\0' then
- printf("\\0\0".ptr)
+ fprintf(stream, "\\0\0".ptr)
elsif c^ = '\n' or c^ = '\t' or c^ = '\r' then
- putchar(cast(c^: Int))
+ fputc(cast(c^: CInt), stream)
elsif c^ < 32u8 or c^ = 127u8 then
- printf("\\x%02X\0".ptr, c^)
+ fprintf(stream, "\\x%02X\0".ptr, c^)
else
- putchar(cast(c^: Int))
+ fputc(cast(c^: CInt), stream)
end
end;
- putchar(cast('"': Int))
+ fputc(cast('"': CInt), stream)
return
-proc elna_lexer_dump_integer(token: ^ElnaLexerIntegerToken)
+proc elna_lexer_dump_integer(token: ^ElnaLexerIntegerToken; stream: ^FILE)
if token^.is_signed then
if token^.size = 0u8 then
- printf("«%lld»\0".ptr, token^.magnitude)
+ fprintf(stream, "«%lld»\0".ptr, token^.magnitude)
else
- printf("«%lldi%d»\0".ptr, token^.magnitude, token^.size)
+ fprintf(stream, "«%lldi%d»\0".ptr, token^.magnitude, token^.size)
end
else
if token^.size = 0u8 then
- printf("«0x%Xu»\0".ptr, token^.magnitude)
+ fprintf(stream, "«0x%Xu»\0".ptr, token^.magnitude)
else
- printf("«0x%Xu%d»\0".ptr, token^.magnitude, token^.size)
+ fprintf(stream, "«0x%Xu%d»\0".ptr, token^.magnitude, token^.size)
end
end
return
--- TODO: Replace printf and other writing functions with a writer callback.
--- TODO: Cursor shouldn't be a parameter, only token.
-proc elna_lexer_token_dump*(token: ^ElnaLexerToken; cursor: ^ElnaLexerCursor)
- printf("⟨\0".ptr);
+proc elna_lexer_token_dump*(token: ^ElnaLexerToken; stream: ^FILE)
+ fprintf(stream, "⟨\0".ptr);
case token^.kind of
- ElnaLexerTokenKind.comment: elna_lexer_token_dump_comment(cast(token: ^ElnaLexerCommentToken)) |
- ElnaLexerTokenKind.docblock: elna_lexer_token_dump_docblock(cast(token: ^ElnaLexerCommentToken)) |
- ElnaLexerTokenKind.if_: printf("«if»\0".ptr) |
- ElnaLexerTokenKind.then_: printf("«then»\0".ptr) |
- ElnaLexerTokenKind.else_: printf("«else»\0".ptr) |
- ElnaLexerTokenKind.elsif_: printf("«elsif»\0".ptr) |
- ElnaLexerTokenKind.while_: printf("«while»\0".ptr) |
- ElnaLexerTokenKind.for_: printf("«for»\0".ptr) |
- ElnaLexerTokenKind.repeat_: printf("«repeat»\0".ptr) |
- ElnaLexerTokenKind.until_: printf("«until»\0".ptr) |
- ElnaLexerTokenKind.with_: printf("«with»\0".ptr) |
- ElnaLexerTokenKind.do_: printf("«do»\0".ptr) |
- ElnaLexerTokenKind.proc_: printf("«proc»\0".ptr) |
- ElnaLexerTokenKind.begin_: printf("«begin»\0".ptr) |
- ElnaLexerTokenKind.end_: printf("«end»\0".ptr) |
- ElnaLexerTokenKind.extern_: printf("«extern»\0".ptr) |
- ElnaLexerTokenKind.const_: printf("«const»\0".ptr) |
- ElnaLexerTokenKind.var_: printf("«var»\0".ptr) |
- ElnaLexerTokenKind.threadvar_: printf("«threadvar»\0".ptr) |
- ElnaLexerTokenKind.type_: printf("«type»\0".ptr) |
- ElnaLexerTokenKind.record_: printf("«record»\0".ptr) |
- ElnaLexerTokenKind.true_: printf("«true»\0".ptr) |
- ElnaLexerTokenKind.false_: printf("«false»\0".ptr) |
- ElnaLexerTokenKind.and: printf("«&»\0".ptr) |
- ElnaLexerTokenKind.xor_: printf("«xor»\0".ptr) |
- ElnaLexerTokenKind.or_: printf("«or»\0".ptr) |
- ElnaLexerTokenKind.pipe: printf("«|»\0".ptr) |
- ElnaLexerTokenKind.not: printf("«~»\0".ptr) |
- ElnaLexerTokenKind.return_: printf("«return»\0".ptr) |
- ElnaLexerTokenKind.import_: printf("«import»\0".ptr) |
- ElnaLexerTokenKind.cast_: printf("«cast»\0".ptr) |
- ElnaLexerTokenKind.defer_: printf("«defer»\0".ptr) |
- ElnaLexerTokenKind.block_: printf("«block»\0".ptr) |
- ElnaLexerTokenKind.break_: printf("«break»\0".ptr) |
- ElnaLexerTokenKind.case_: printf("«case»\0".ptr) |
- ElnaLexerTokenKind.of_: printf("«of»\0".ptr) |
- ElnaLexerTokenKind.to_: printf("«to»\0".ptr) |
- ElnaLexerTokenKind.program_: printf("«program»\0".ptr) |
- ElnaLexerTokenKind.module_: printf("«module»\0".ptr) |
+ 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.identifier:
var
identifier := cast(token: ^ElnaLexerIdentifierToken)^.identifier
begin
- printf("Identifier «%.*s»\0".ptr, identifier.length, identifier.ptr)
+ fprintf(stream, "Identifier «%.*s»\0".ptr, identifier.length, identifier.ptr)
|
ElnaLexerTokenKind.trait:
var
identifier := cast(token: ^ElnaLexerIdentifierToken)^.identifier
begin
- printf("#%.*s\0".ptr, identifier.length, identifier.ptr)
+ fprintf(stream, "#%.*s\0".ptr, identifier.length, identifier.ptr)
|
- ElnaLexerTokenKind.generic_open: printf("«#[»\0".ptr) |
- ElnaLexerTokenKind.attribute_open: printf("«#{»\0".ptr) |
- ElnaLexerTokenKind.integer: elna_lexer_dump_integer(cast(token: ^ElnaLexerIntegerToken)) |
+ 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.double:
- printf("«%g»\0".ptr, cast(token: ^ElnaLexerFloatToken)^.value) |
+ fprintf(stream, "«%g»\0".ptr, cast(token: ^ElnaLexerFloatToken)^.value) |
ElnaLexerTokenKind.single:
- printf("«%gf»\0".ptr, cast(token: ^ElnaLexerFloatToken)^.value) |
+ fprintf(stream, "«%gf»\0".ptr, cast(token: ^ElnaLexerFloatToken)^.value) |
ElnaLexerTokenKind.character:
- printf("\\{U+%X}\0".ptr, cast(token: ^ElnaLexerCharacterToken)^.codepoint) |
- ElnaLexerTokenKind.string: elna_lexer_dump_string(cast(token: ^ElnaLexerStringToken)) |
- ElnaLexerTokenKind.left_paren: printf("«(»\0".ptr) |
- ElnaLexerTokenKind.right_paren: printf("«)»\0".ptr) |
- ElnaLexerTokenKind.left_square: printf("«[»\0".ptr) |
- ElnaLexerTokenKind.right_square: printf("«]»\0".ptr) |
- ElnaLexerTokenKind.left_brace: printf("«{»\0".ptr) |
- ElnaLexerTokenKind.right_brace: printf("«}»\0".ptr) |
- ElnaLexerTokenKind.shift_left: printf("«<<»\0".ptr) |
- ElnaLexerTokenKind.shift_right: printf("«>>»\0".ptr) |
- ElnaLexerTokenKind.greater_equal: printf("«>=»\0".ptr) |
- ElnaLexerTokenKind.less_equal: printf("«<=»\0".ptr) |
- ElnaLexerTokenKind.greater_than: printf("«>»\0".ptr) |
- ElnaLexerTokenKind.less_than: printf("«<»\0".ptr) |
- ElnaLexerTokenKind.not_equal: printf("«<>»\0".ptr) |
- ElnaLexerTokenKind.equals: printf("«=»\0".ptr) |
- ElnaLexerTokenKind.semicolon: printf("«;»\0".ptr) |
- ElnaLexerTokenKind.dot: printf("«.»\0".ptr) |
- ElnaLexerTokenKind.comma: printf("«,»\0".ptr) |
- ElnaLexerTokenKind.plus: printf("«+»\0".ptr) |
- ElnaLexerTokenKind.minus: printf("«-»\0".ptr) |
- ElnaLexerTokenKind.multiplication: printf("«*»\0".ptr) |
- ElnaLexerTokenKind.division: printf("«/»\0".ptr) |
- ElnaLexerTokenKind.remainder: printf("«%»\0".ptr) |
- ElnaLexerTokenKind.assignment: printf("«:=»\0".ptr) |
- ElnaLexerTokenKind.colon: printf("«:»\0".ptr) |
- ElnaLexerTokenKind.hat: printf("«^»\0".ptr) |
- ElnaLexerTokenKind.at: printf("«@»\0".ptr) |
- ElnaLexerTokenKind.arrow: printf("«->»\0".ptr) |
- ElnaLexerTokenKind.eof: printf("EOF\0".ptr)
+ 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)
end;
- printf("; Position: %lu⟩\n\0".ptr, cursor^.position)
+ fprintf(stream, "; Position: [%lu, %lu)⟩\n\0".ptr, token^.position.start_offset, token^.position.end_offset)
return
end.
diff --git a/source/elna/parser.elna b/source/elna/parser.elna
new file mode 100644
index 0000000..d1448fa
--- /dev/null
+++ b/source/elna/parser.elna
@@ -0,0 +1,29 @@
+(* 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/. *)
+
+(* Syntactic analysis. *)
+module
+
+import sys.posix.stdlib, sys.posix.stdio, std, elna.lexer, elna.ast
+
+proc elna_parser_program*(lexer_cursor: ^ElnaLexerCursor) -> StdOptional#[ElnaAstUnit]
+var
+ token: ^ElnaLexerToken
+ unit: ^ElnaAstUnit
+begin
+ token := elna_lexer_lex(lexer_cursor).value;
+ elna_lexer_token_dump(token, stderr_());
+
+ while token^.kind <> ElnaLexerTokenKind.eof do
+ elna_lexer_token_destroy(token);
+
+ token := elna_lexer_lex(lexer_cursor).value;
+ elna_lexer_token_dump(token, stderr_())
+ end;
+ elna_lexer_token_destroy(token);
+
+ unit := malloc#[ElnaAstUnit](#size(ElnaAstUnit))
+return std_optional_make(unit)
+
+end.
diff --git a/source/main.elna b/source/main.elna
index fb1ae86..ebdeee1 100644
--- a/source/main.elna
+++ b/source/main.elna
@@ -2,12 +2,13 @@
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, elna.lexer
+import sys.posix.stdio, std, elna.lexer, elna.ast, elna.parser
var
global_cursor: ElnaLexerCursor
sample_source_text := "Here.a few (* documentation block *) or #size if '\\n' `У` \"некоторая строка\" 23 -- End line comment\0"
token: ^ElnaLexerToken
+ tree: StdOptional#[ElnaAstUnit]
begin
elna_lexer_transitions();
@@ -17,14 +18,7 @@ begin
position: 1u
};
- token := elna_lexer_lex(@global_cursor);
- elna_lexer_token_dump(token, @global_cursor);
+ tree := elna_parser_program(@global_cursor);
- while token^.kind <> ElnaLexerTokenKind.eof do
- elna_lexer_token_destroy(token);
-
- token := elna_lexer_lex(@global_cursor);
- elna_lexer_token_dump(token, @global_cursor)
- end;
- elna_lexer_token_destroy(token)
+ puts("void main(){}\0".ptr)
end.
diff --git a/source/sys/posix/stdio.elna b/source/sys/posix/stdio.elna
index 39756a8..c667f43 100644
--- a/source/sys/posix/stdio.elna
+++ b/source/sys/posix/stdio.elna
@@ -3,13 +3,27 @@
obtain one at https://mozilla.org/MPL/2.0/. *)
module
-proc printf*(format: ^const Word8) #{varargs} -> Int
+import sys.ffi, bits.stdio*
+
+proc fprintf*(stream: ^FILE; format: ^const CChar) #{varargs} -> CInt
+extern
+
+proc printf*(format: ^const CChar) #{varargs} -> CInt
+extern
+
+proc fputs*(s: ^const CChar; stream: ^FILE) -> CInt
+extern
+
+proc puts*(s: ^const CChar) -> CInt
extern
-proc puts*(s: ^const Word8) -> Int
+proc fputc*(c: CInt; stream: ^FILE) -> CInt
extern
-proc putchar*(c: Int) -> Int
+proc putc*(c: CInt; stream: ^FILE) -> CInt
+return fputc(c, stream)
+
+proc putchar*(c: CInt) -> CInt
extern
end.
diff --git a/source/sys/posix/stdlib.elna b/source/sys/posix/stdlib.elna
index 497e87d..272400a 100644
--- a/source/sys/posix/stdlib.elna
+++ b/source/sys/posix/stdlib.elna
@@ -3,6 +3,8 @@
obtain one at https://mozilla.org/MPL/2.0/. *)
module
+import sys.ffi
+
proc malloc#[T]*(size: Word) -> ^T
extern
@@ -12,19 +14,22 @@ extern
proc realloc#[T]*(ptr: ^T; size: Word) -> ^T
extern
-proc strtol*(str: ^const Word8; endptr: ^^Word8; base: Int) -> Int
+proc strtol*(str: ^const CChar; endptr: ^^CChar; base: CInt) -> CLong
+extern
+
+proc strtoll*(str: ^const CChar; endptr: ^^CChar; base: CInt) -> CLongLong
extern
-proc strtoul*(str: ^const Word8; endptr: ^^Word8; base: Int) -> Word
+proc strtoul*(str: ^const CChar; endptr: ^^CChar; base: CInt) -> CULong
extern
-proc strtoull*(str: ^const Word8; endptr: ^^Word8; base: Int) -> Word64
+proc strtoull*(str: ^const CChar; endptr: ^^CChar; base: CInt) -> CULongLong
extern
-proc strtof*(nptr: ^const Word8; endptr: ^^Word8) -> Single
+proc strtof*(nptr: ^const CChar; endptr: ^^CChar) -> Single
extern
-proc strtod*(nptr: ^const Word8; endptr: ^^Word8) -> Double
+proc strtod*(nptr: ^const CChar; endptr: ^^CChar) -> Double
extern
end.
diff --git a/source/sys/posix/string.elna b/source/sys/posix/string.elna
index 561d975..a9a1ce9 100644
--- a/source/sys/posix/string.elna
+++ b/source/sys/posix/string.elna
@@ -3,13 +3,15 @@
obtain one at https://mozilla.org/MPL/2.0/. *)
module
-proc memset#[T]*(b: ^T; c: Int; len: Word) -> ^T
+import sys.ffi
+
+proc memset#[T]*(b: ^T; c: CInt; len: Word) -> ^T
extern
proc memcpy#[T]*(dst: ^T; src: ^const T; n: Word) -> ^T
extern
-proc memchr#[T]*(s: ^T; c: Int; n: Word) -> ^T
+proc memchr#[T]*(s: ^T; c: CInt; n: Word) -> ^T
extern
end.