diff options
Diffstat (limited to 'source')
| -rw-r--r-- | source/elna/lexer.elna | 247 | ||||
| -rw-r--r-- | source/elna/parser.elna | 26 | ||||
| -rw-r--r-- | source/elna/source.elna | 136 | ||||
| -rw-r--r-- | source/main.elna | 33 | ||||
| -rw-r--r-- | source/sys/posix/stdio.elna | 3 | ||||
| -rw-r--r-- | source/sys/posix/stdlib.elna | 6 |
6 files changed, 328 insertions, 123 deletions
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. |
