* [PATCH olang v2 2/4] string_view: add string view conversion to uint32_t
2024-03-01 22:24 [PATCH olang v2 0/4] create initial syntax analysis logic Johnny Richard
2024-03-01 22:24 ` [PATCH olang v2 1/4] string_view: add string view formatter for printf fmt Johnny Richard
@ 2024-03-01 22:24 ` Johnny Richard
2024-03-01 22:24 ` [PATCH olang v2 3/4] lexer: add token lookahead capability Johnny Richard
2024-03-01 22:24 ` [PATCH olang v2 4/4] parser: create simplified parser for tiny AST Johnny Richard
3 siblings, 0 replies; 7+ messages in thread
From: Johnny Richard @ 2024-03-01 22:24 UTC (permalink / raw)
To: ~johnnyrichard/olang-devel; +Cc: Johnny Richard
Signed-off-by: Johnny Richard <johnny@johnnyrichard.com>
---
v2: add slice string view test.
replace memset call with a regular index assignment
src/string_view.c | 11 ++++++
src/string_view.h | 5 ++-
tests/unit/string_view_test.c | 67 +++++++++++++++++++++++++++++++++++
3 files changed, 82 insertions(+), 1 deletion(-)
create mode 100644 tests/unit/string_view_test.c
diff --git a/src/string_view.c b/src/string_view.c
index 122eaa2..084f417 100644
--- a/src/string_view.c
+++ b/src/string_view.c
@@ -17,6 +17,8 @@
#include "string_view.h"
#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
#include <string.h>
bool
@@ -33,3 +35,12 @@ string_view_eq_to_cstr(string_view_t str, char *cstr)
}
return i == cstr_len;
}
+
+uint32_t
+string_view_to_u32(string_view_t str)
+{
+ char ret[str.size + 1];
+ ret[str.size + 1] = 0;
+ memcpy(ret, str.chars, str.size);
+ return atoi(ret);
+}
diff --git a/src/string_view.h b/src/string_view.h
index 1adc5c0..d5d2e6c 100644
--- a/src/string_view.h
+++ b/src/string_view.h
@@ -19,6 +19,7 @@
#include <stdbool.h>
#include <stddef.h>
+#include <stdint.h>
#define SV_FMT "%.*s"
#define SV_ARG(sv) (int)(sv).size, (sv).chars
@@ -30,8 +31,10 @@ typedef struct string_view
} string_view_t;
-// TODO: missing unit test
bool
string_view_eq_to_cstr(string_view_t str, char *cstr);
+uint32_t
+string_view_to_u32(string_view_t str);
+
#endif /* STRING_VIEW_T */
diff --git a/tests/unit/string_view_test.c b/tests/unit/string_view_test.c
new file mode 100644
index 0000000..1d8627f
--- /dev/null
+++ b/tests/unit/string_view_test.c
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2024 olang maintainers
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+#define MUNIT_ENABLE_ASSERT_ALIASES
+#include "munit.h"
+#include "string_view.h"
+
+#include <stdio.h>
+#include <string.h>
+
+static MunitResult
+string_view_eq_to_cstr_test(const MunitParameter params[], void *user_data_or_fixture)
+{
+ char *name = "John Doe";
+
+ string_view_t str = { .chars = name, .size = strlen(name) };
+
+ assert_true(string_view_eq_to_cstr(str, "John Doe"));
+ assert_false(string_view_eq_to_cstr(str, "Doe"));
+
+ char *return_stmt = "return EXIT_SUCCESS;";
+
+ str = (string_view_t){ .chars = return_stmt + 7, .size = 12 };
+ assert_true(string_view_eq_to_cstr(str, "EXIT_SUCCESS"));
+
+ return MUNIT_OK;
+}
+
+static MunitResult
+string_view_to_u32_test(const MunitParameter params[], void *user_data_or_fixture)
+{
+ char *number = "69";
+
+ string_view_t str = { .chars = number, .size = strlen(number) };
+
+ assert_uint32(string_view_to_u32(str), ==, 69);
+
+ return MUNIT_OK;
+}
+
+static MunitTest tests[] = {
+ { "/eq_to_cstr_test", string_view_eq_to_cstr_test, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL },
+ { "/to_u32_test", string_view_to_u32_test, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL },
+ { NULL, NULL, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL }
+};
+
+static const MunitSuite suite = { "/string_view", tests, NULL, 1, MUNIT_SUITE_OPTION_NONE };
+
+int
+main(int argc, char *argv[])
+{
+ return munit_suite_main(&suite, NULL, argc, argv);
+ return EXIT_SUCCESS;
+}
--
2.43.2
^ permalink raw reply [flat|nested] 7+ messages in thread* [PATCH olang v2 4/4] parser: create simplified parser for tiny AST
2024-03-01 22:24 [PATCH olang v2 0/4] create initial syntax analysis logic Johnny Richard
` (2 preceding siblings ...)
2024-03-01 22:24 ` [PATCH olang v2 3/4] lexer: add token lookahead capability Johnny Richard
@ 2024-03-01 22:24 ` Johnny Richard
2024-03-01 21:32 ` [olang/patches/.build.yml] build success builds.sr.ht
2024-03-01 22:08 ` [PATCH olang v2 4/4] parser: create simplified parser for tiny AST Carlos Maniero
3 siblings, 2 replies; 7+ messages in thread
From: Johnny Richard @ 2024-03-01 22:24 UTC (permalink / raw)
To: ~johnnyrichard/olang-devel; +Cc: Johnny Richard
This commit introduces a simple and restricted parser designed to handle
a small program structure. Its purpose is to lay the foundation for
future optimizations.
Error handling during syntax analysis is rudimentary. If an error
occurs, it will be printed, and the program will abort without further
parsing to detect additional syntax errors.
Additionally, it's important to note that semantic analysis will be
conducted at a later stage in the compiler pipeline. As only u32 type is
currently implemented, a separate type checker will not be developed.
Consequently, the AST generated during syntax analysis can be directly
passed to the backend.
Signed-off-by: Johnny Richard <johnny@johnnyrichard.com>
---
v2:
- replace ast_make_node_... by ast_new_node_...
- replace function lexer_print_token_highlight to
lexer_get_token_line, this change also removes the IO handling
within the lexer.
src/ast.c | 79 +++++++++++++++
src/ast.h | 101 ++++++++++++++++++++
src/lexer.c | 14 +++
src/lexer.h | 4 +
src/parser.c | 202 +++++++++++++++++++++++++++++++++++++++
src/parser.h | 38 ++++++++
tests/unit/parser_test.c | 88 +++++++++++++++++
7 files changed, 526 insertions(+)
create mode 100644 src/ast.c
create mode 100644 src/ast.h
create mode 100644 src/parser.c
create mode 100644 src/parser.h
create mode 100644 tests/unit/parser_test.c
diff --git a/src/ast.c b/src/ast.c
new file mode 100644
index 0000000..fb39295
--- /dev/null
+++ b/src/ast.c
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2024 olang maintainers
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <assert.h>
+#include <stdint.h>
+
+#include "arena.h"
+#include "ast.h"
+#include "string_view.h"
+
+ast_node_t *
+ast_new_node_fn_def(arena_t *arena, string_view_t identifier, type_t return_type, ast_node_t *block)
+{
+ ast_node_t *node_fn_def = (ast_node_t *)arena_alloc(arena, sizeof(ast_node_t));
+ assert(node_fn_def);
+
+ node_fn_def->kind = AST_NODE_FN_DEF;
+ ast_fn_definition_t *fn_def = &node_fn_def->data.as_fn_def;
+
+ fn_def->identifier = identifier;
+ fn_def->return_type = return_type;
+ fn_def->block = block;
+
+ return node_fn_def;
+}
+
+ast_node_t *
+ast_new_node_literal_u32(arena_t *arena, uint32_t value)
+{
+ ast_node_t *node_literal = (ast_node_t *)arena_alloc(arena, sizeof(ast_node_t));
+ assert(node_literal);
+
+ node_literal->kind = AST_NODE_LITERAL;
+ node_literal->data.as_literal.kind = AST_LITERAL_U32;
+ node_literal->data.as_literal.value.as_u32 = value;
+
+ return node_literal;
+}
+
+ast_node_t *
+ast_new_node_return_stmt(arena_t *arena)
+{
+ ast_node_t *node_return_stmt = (ast_node_t *)arena_alloc(arena, sizeof(ast_node_t));
+ assert(node_return_stmt);
+
+ node_return_stmt->kind = AST_NODE_RETURN_STMT;
+
+ return node_return_stmt;
+}
+
+ast_node_t *
+ast_new_node_block(arena_t *arena)
+{
+ ast_node_t *node_block = (ast_node_t *)arena_alloc(arena, sizeof(ast_node_t));
+ assert(node_block);
+
+ node_block->kind = AST_NODE_BLOCK;
+
+ node_block->data.as_block.nodes = (list_t *)arena_alloc(arena, sizeof(list_t));
+ assert(node_block->data.as_block.nodes);
+
+ list_init(node_block->data.as_block.nodes, arena);
+
+ return node_block;
+}
diff --git a/src/ast.h b/src/ast.h
new file mode 100644
index 0000000..b243334
--- /dev/null
+++ b/src/ast.h
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2024 olang maintainers
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+#ifndef AST_H
+#define AST_H
+
+#include <stdint.h>
+
+#include "arena.h"
+#include "list.h"
+#include "string_view.h"
+
+typedef struct ast_node ast_node_t;
+
+typedef enum
+{
+ AST_NODE_BLOCK,
+ AST_NODE_FN_DEF,
+ AST_NODE_RETURN_STMT,
+ AST_NODE_LITERAL,
+ AST_NODE_UNKNOWN
+} ast_node_kind_t;
+
+typedef enum
+{
+ TYPE_U32
+} type_t;
+
+typedef struct ast_block
+{
+ list_t *nodes;
+} ast_block_t;
+
+typedef struct ast_fn_definition
+{
+ string_view_t identifier;
+ type_t return_type;
+ ast_node_t *block;
+} ast_fn_definition_t;
+
+typedef enum
+{
+ AST_LITERAL_U32
+} ast_literal_kind_t;
+
+typedef union
+{
+ uint32_t as_u32;
+} ast_literal_value_t;
+
+typedef struct ast_literal
+{
+ ast_literal_kind_t kind;
+ ast_literal_value_t value;
+} ast_literal_t;
+
+typedef struct ast_return_stmt
+{
+ ast_node_t *data;
+} ast_return_stmt_t;
+
+typedef union
+{
+ ast_fn_definition_t as_fn_def;
+ ast_literal_t as_literal;
+ ast_block_t as_block;
+ ast_return_stmt_t as_return_stmt;
+} ast_node_data_t;
+
+typedef struct ast_node
+{
+ ast_node_kind_t kind;
+ ast_node_data_t data;
+} ast_node_t;
+
+ast_node_t *
+ast_new_node_fn_def(arena_t *arena, string_view_t identifier, type_t return_type, ast_node_t *block);
+
+ast_node_t *
+ast_new_node_literal_u32(arena_t *arena, uint32_t value);
+
+ast_node_t *
+ast_new_node_return_stmt(arena_t *arena);
+
+ast_node_t *
+ast_new_node_block(arena_t *arena);
+
+#endif /* AST_H */
diff --git a/src/lexer.c b/src/lexer.c
index c7756a6..dd6f11d 100644
--- a/src/lexer.c
+++ b/src/lexer.c
@@ -19,6 +19,7 @@
#include <assert.h>
#include <ctype.h>
#include <stdbool.h>
+#include <stdio.h>
void
lexer_init(lexer_t *lexer, string_view_t source)
@@ -255,3 +256,16 @@ lexer_lookahead(lexer_t *lexer, token_t *token, size_t n)
lexer->row = previous_row;
lexer->bol = previous_bol;
}
+
+string_view_t
+lexer_get_token_line(lexer_t *lexer, token_t *token)
+{
+ size_t offset = token->location.bol;
+ string_view_t line = { .chars = lexer->source.chars + offset, .size = 0 };
+
+ while ((line.size + offset) < lexer->source.size && line.chars[line.size] != '\n' && line.chars[line.size] != 0) {
+ ++line.size;
+ }
+
+ return line;
+}
diff --git a/src/lexer.h b/src/lexer.h
index 729c957..cb91d7e 100644
--- a/src/lexer.h
+++ b/src/lexer.h
@@ -19,6 +19,7 @@
#include "string_view.h"
#include <stdint.h>
+#include <stdio.h>
typedef struct lexer
{
@@ -77,4 +78,7 @@ lexer_lookahead(lexer_t *lexer, token_t *token, size_t n);
char *
token_kind_to_cstr(token_kind_t kind);
+string_view_t
+lexer_get_token_line(lexer_t *lexer, token_t *token);
+
#endif /* LEXER_H */
diff --git a/src/parser.c b/src/parser.c
new file mode 100644
index 0000000..a9699be
--- /dev/null
+++ b/src/parser.c
@@ -0,0 +1,202 @@
+/*
+ * Copyright (C) 2024 olang maintainers
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+#include "lexer.h"
+#include "parser.h"
+
+static bool
+skip_expected_token(parser_t *parser, token_kind_t expected_kind);
+
+static bool
+expected_token(parser_t *parser, token_t *token, token_kind_t kind);
+
+static bool
+parser_parse_type(parser_t *parser, type_t *type);
+
+static ast_node_t *
+parser_parse_block(parser_t *parser);
+
+static void
+skip_line_feeds(lexer_t *lexer);
+
+void
+parser_init(parser_t *parser, lexer_t *lexer, arena_t *arena, char *file_path)
+{
+ assert(parser && "parser is required");
+ assert(lexer && "lexer is required");
+ assert(file_path && "file_path is required");
+ parser->lexer = lexer;
+ parser->arena = arena;
+ parser->file_path = file_path;
+}
+
+ast_node_t *
+parser_parse_fn_definition(parser_t *parser)
+{
+ if (!skip_expected_token(parser, TOKEN_FN)) {
+ return NULL;
+ }
+
+ skip_line_feeds(parser->lexer);
+
+ token_t fn_name_token;
+
+ if (!expected_token(parser, &fn_name_token, TOKEN_IDENTIFIER)) {
+ return NULL;
+ }
+
+ skip_line_feeds(parser->lexer);
+
+ if (!skip_expected_token(parser, TOKEN_OPAREN)) {
+ return NULL;
+ }
+
+ skip_line_feeds(parser->lexer);
+
+ if (!skip_expected_token(parser, TOKEN_CPAREN)) {
+ return NULL;
+ }
+
+ skip_line_feeds(parser->lexer);
+
+ if (!skip_expected_token(parser, TOKEN_COLON)) {
+ return NULL;
+ }
+
+ skip_line_feeds(parser->lexer);
+
+ type_t fn_return_type;
+ if (!parser_parse_type(parser, &fn_return_type)) {
+ return NULL;
+ }
+
+ skip_line_feeds(parser->lexer);
+
+ ast_node_t *block = parser_parse_block(parser);
+ if (block == NULL) {
+ return NULL;
+ }
+
+ return ast_new_node_fn_def(parser->arena, fn_name_token.value, fn_return_type, block);
+}
+
+static bool
+parser_parse_type(parser_t *parser, type_t *type)
+{
+ token_t token;
+
+ if (!expected_token(parser, &token, TOKEN_IDENTIFIER)) {
+ return false;
+ }
+
+ if (string_view_eq_to_cstr(token.value, "u32")) {
+ *type = TYPE_U32;
+ return true;
+ }
+
+ return false;
+}
+
+static ast_node_t *
+parser_parse_block(parser_t *parser)
+{
+ token_t number_token;
+ if (!skip_expected_token(parser, TOKEN_OCURLY)) {
+ return false;
+ }
+
+ skip_line_feeds(parser->lexer);
+
+ ast_node_t *node_block = ast_new_node_block(parser->arena);
+
+ if (!skip_expected_token(parser, TOKEN_RETURN)) {
+ return false;
+ }
+
+ ast_node_t *node_return_stmt = ast_new_node_return_stmt(parser->arena);
+ assert(node_return_stmt);
+
+ if (!expected_token(parser, &number_token, TOKEN_NUMBER)) {
+ return false;
+ }
+
+ ast_node_t *literal_node = ast_new_node_literal_u32(parser->arena, string_view_to_u32(number_token.value));
+ assert(literal_node);
+
+ node_return_stmt->data.as_return_stmt.data = literal_node;
+
+ list_append(node_block->data.as_block.nodes, node_return_stmt);
+
+ if (!skip_expected_token(parser, TOKEN_LF)) {
+ return false;
+ }
+
+ skip_line_feeds(parser->lexer);
+
+ if (!skip_expected_token(parser, TOKEN_CCURLY)) {
+ return false;
+ }
+
+ return node_block;
+}
+
+static bool
+skip_expected_token(parser_t *parser, token_kind_t expected_kind)
+{
+ token_t token;
+ return expected_token(parser, &token, expected_kind);
+}
+
+static bool
+expected_token(parser_t *parser, token_t *token, token_kind_t expected_kind)
+{
+ lexer_next_token(parser->lexer, token);
+
+ if (token->kind != expected_kind) {
+ fprintf(stderr,
+ "%s:%lu:%lu: error: got <%s> token but expect <%s>\n",
+ parser->file_path,
+ token->location.row + 1,
+ (token->location.offset - token->location.bol) + 1,
+ token_kind_to_cstr(token->kind),
+ token_kind_to_cstr(expected_kind));
+
+ string_view_t line = lexer_get_token_line(parser->lexer, token);
+ fprintf(stderr, "" SV_FMT "\n", SV_ARG(line));
+ fprintf(stderr, "%*s\n", (int)(token->location.offset - token->location.bol + 1), "^");
+
+ return false;
+ }
+ return true;
+}
+
+static void
+skip_line_feeds(lexer_t *lexer)
+{
+ token_t token;
+ lexer_peek_next(lexer, &token);
+
+ while (token.kind == TOKEN_LF) {
+ lexer_next_token(lexer, &token);
+ lexer_peek_next(lexer, &token);
+ }
+}
diff --git a/src/parser.h b/src/parser.h
new file mode 100644
index 0000000..3f1a00b
--- /dev/null
+++ b/src/parser.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2024 olang maintainers
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+#ifndef PARSER_H
+#define PARSER_H
+
+#include "arena.h"
+#include "ast.h"
+#include "lexer.h"
+
+typedef struct parser
+{
+ lexer_t *lexer;
+ arena_t *arena;
+ // TODO: we should define a better place to file_path string
+ char *file_path;
+} parser_t;
+
+void
+parser_init(parser_t *parser, lexer_t *lexer, arena_t *arena, char *file_path);
+
+ast_node_t *
+parser_parse_fn_definition(parser_t *parser);
+
+#endif /* PARSER_H */
diff --git a/tests/unit/parser_test.c b/tests/unit/parser_test.c
new file mode 100644
index 0000000..32ebc8e
--- /dev/null
+++ b/tests/unit/parser_test.c
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2024 olang maintainers
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+#define MUNIT_ENABLE_ASSERT_ALIASES
+
+#include "arena.h"
+#include "ast.h"
+#include "lexer.h"
+#include "list.h"
+#include "munit.h"
+#include "parser.h"
+#include "string_view.h"
+
+#define ARENA_CAPACITY (1024 * 1024)
+
+static MunitResult
+parse_fn_definition_test(const MunitParameter params[], void *user_data_or_fixture)
+{
+ arena_t arena = arena_new(ARENA_CAPACITY);
+
+ char *file_path = "main.0";
+ char *source_value = "fn main(): u32 {\n\treturn 69\n}";
+
+ lexer_t lexer;
+ string_view_t source = { .chars = source_value, .size = strlen(source_value) };
+ lexer_init(&lexer, source);
+
+ parser_t parser;
+ parser_init(&parser, &lexer, &arena, file_path);
+
+ ast_node_t *node_fn_def = parser_parse_fn_definition(&parser);
+ assert_not_null(node_fn_def);
+ assert_uint(node_fn_def->kind, ==, AST_NODE_FN_DEF);
+
+ ast_fn_definition_t *fn = &node_fn_def->data.as_fn_def;
+ assert_memory_equal(fn->identifier.size, fn->identifier.chars, "main");
+ assert_uint(fn->return_type, ==, TYPE_U32);
+
+ ast_node_t *block = fn->block;
+ assert_not_null(block);
+
+ assert_uint(block->kind, ==, AST_NODE_BLOCK);
+ assert_uint(list_size(block->data.as_block.nodes), ==, 1);
+ list_item_t *block_item = list_get(block->data.as_block.nodes, 0);
+ assert_not_null(block_item);
+ assert_not_null(block_item->value);
+
+ ast_node_t *node = (ast_node_t *)block_item->value;
+ assert_not_null(node);
+ assert_uint(node->kind, ==, AST_NODE_RETURN_STMT);
+
+ ast_node_t *number_node = node->data.as_return_stmt.data;
+ assert_not_null(number_node);
+ assert_uint(number_node->kind, ==, AST_NODE_LITERAL);
+ assert_uint(number_node->data.as_literal.kind, ==, AST_LITERAL_U32);
+ assert_uint(number_node->data.as_literal.value.as_u32, ==, 69);
+
+ arena_free(&arena);
+
+ return MUNIT_OK;
+}
+
+static MunitTest tests[] = {
+ { "/parse_fn_definition", parse_fn_definition_test, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL },
+ { NULL, NULL, NULL, NULL, MUNIT_TEST_OPTION_NONE, NULL }
+};
+
+static const MunitSuite suite = { "/parser", tests, NULL, 1, MUNIT_SUITE_OPTION_NONE };
+
+int
+main(int argc, char *argv[])
+{
+ return munit_suite_main(&suite, NULL, argc, argv);
+ return EXIT_SUCCESS;
+}
--
2.43.2
^ permalink raw reply [flat|nested] 7+ messages in thread