zzy/scc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(ast): 将AST上下文重构为模块并添加字符串池支持

Browse Source 
- 将scc_ast_ctx重命名为scc_ast_module以更好地反映其功能
- 添加scc_strpool_t用于统一管理AST节点名称字符串的生命周期
- 实现scc_ast_module_intern函数用于字符串驻留
- 更新所有相关的初始化、销毁和访问函数命名
- 修改内存分配宏以使用新的模块结构

refactor(parser): 更新解析器以使用AST模块和字符串池

- 将解析器中的ast_ctx字段替换为ast_module
- 在创建AST节点时使用新的ast_module参数
- 使用scc_ast_module_intern函数处理标识符和字符串字面量
- 确保所有字符串都被正确驻留到模块的字符串池中

refactor(sema): 更新语义分析器使用AST模块

- 将sema_ctx中的ast_ctx字段替换为ast_module
- 更新语义分析器初始化函数参数

refactor(ast2ir): 更新AST到IR转换器使用AST模块

- 将ast_ctx字段替换为ast_module
- 更新上下文初始化函数参数和实现

fix(cfg): 修复CFG模块中的符号查找错误

- 修正scc_cfg_module_unsafe_get_symbol函数中的边界检查条件

perf(ir): 完善各IR层模块的内存清理机制

- 为HIR模块添加函数和基本块元数据的释放逻辑
- 为MIR和LIR模块完善完整的资源清理和内存释放
- 确保所有分配的元数据结构都能被正确释放

chore(deps): 添加scc_utils依赖到AST库

- 在libs/ast/cbuild.toml中添加对scc_utils的依赖
This commit is contained in:
zzy
2026-05-31 19:56:19 +08:00
parent d2eafa9dc6
commit 8b817da3b6
31 changed files with 409 additions and 179 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
libs/parser/include/scc_parser.h
View File

@@ -14,7 +14,7 @@ typedef struct scc_parser {
scc_lexer_tok_ring_t *ring;
usize checkpoint;
scc_ast_ctx_t *ast_ctx;
scc_ast_module_t *ast_module;
scc_sema_ctx_t *sema_ctx;
int owned_sema;
scc_ast_translation_unit_t *translation_unit;
@@ -28,7 +28,7 @@ typedef struct scc_parser {
* @param callbacks 语义分析回调(可为 nullptr)
*/
void scc_parser_init(scc_parser_t *parser, scc_lexer_tok_ring_t *tok_ring,
scc_ast_ctx_t *ast_ctx, scc_sema_ctx_t *callbacks);
scc_ast_module_t *ast_module, scc_sema_ctx_t *callbacks);
/**
* @brief 销毁解析器

4
libs/parser/include/scc_sema.h
View File

@@ -29,7 +29,7 @@ struct scc_sema_ctx {
scc_sema_callback_t on_expr;
scc_sema_callback_t on_type;
scc_sema_got_type_t got_type;
scc_ast_ctx_t *ast_ctx;
scc_ast_module_t *ast_module;
scc_ast_stmt_vec_t break_stack;
scc_ast_stmt_vec_t continue_stack;
@@ -37,7 +37,7 @@ struct scc_sema_ctx {
void *context;
};
void scc_sema_init(scc_sema_ctx_t *sema_ctx, scc_ast_ctx_t *ast_ctx);
void scc_sema_init(scc_sema_ctx_t *sema_ctx, scc_ast_module_t *ast_module);
void scc_sema_drop(scc_sema_ctx_t *sema_ctx);
#endif /* __SCC_SEMA_H__ */

2
libs/parser/include/sema_symtab.h
View File

@@ -2,6 +2,7 @@
#define __SCC_SEMA_SYMTAB_H__
#include <scc_ast.h>
#include <scc_strpool.h>
#include <scc_utils.h>
typedef struct scc_parser_scope {
@@ -12,6 +13,7 @@ typedef struct scc_parser_scope {
typedef struct {
scc_sema_scope_t root_scope;
scc_sema_scope_t *current_scope;
scc_strpool_t name_pool; /* 拥有符号名（生成的标签名等）的生命周期 */
} scc_sema_symtab_t;
void scc_sema_symtab_init(scc_sema_symtab_t *symtab);

14
libs/parser/src/parse_decl.c
View File

@@ -187,7 +187,7 @@ scc_ast_expr_t *scc_parse_initializer(scc_parser_t *parser,
scc_pos_t pos = tok.loc;
scc_lexer_tok_drop(&tok);
init = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
init = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(init != nullptr);
scc_ast_expr_vec_t lhs_exprs;
scc_vec_init(lhs_exprs);
@@ -203,9 +203,9 @@ scc_ast_expr_t *scc_parse_initializer(scc_parser_t *parser,
tok_ptr = scc_parser_peek(parser);
if (tok_ptr && tok_ptr->type == SCC_TOK_IDENT) {
scc_parser_next_consume(parser, &tok);
lhs = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
lhs = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(lhs != nullptr);
scc_ast_expr_member_init(lhs, ptr, scc_str_as_cstr(&tok.lexeme),
scc_ast_expr_member_init(lhs, ptr, scc_ast_module_intern(parser->ast_module, scc_str_as_cstr(&tok.lexeme)),
tok.loc);
if (!scc_parser_consume_if(parser, SCC_TOK_ASSIGN)) {
ptr = lhs;
@@ -231,7 +231,7 @@ scc_ast_expr_t *scc_parse_initializer(scc_parser_t *parser,
if (!scc_parser_consume_if(parser, SCC_TOK_R_BRACKET)) {
SCC_ERROR(scc_parser_got_current_pos(parser), "Expected ']'");
}
lhs = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
lhs = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(lhs != nullptr);
scc_ast_expr_array_subscript_init(lhs, ptr, idx, tok_ptr->loc);
if (!scc_parser_consume_if(parser, SCC_TOK_ASSIGN)) {
@@ -285,7 +285,7 @@ CONTINUE:
if (tok_ptr->type == SCC_TOK_ASSIGN) {
scc_parser_next_consume(parser, nullptr);
// TODO maybe memory leak
scc_ast_expr_t *lvalue = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
scc_ast_expr_t *lvalue = SCC_AST_ALLOC_EXPR(parser->ast_module);
scc_ast_expr_lvalue_init(lvalue, decl->var.type, decl->base.loc);
decl->var.init = scc_parse_initializer(parser, lvalue);
} else if (tok_ptr->type == SCC_TOK_L_BRACE) {
@@ -348,7 +348,7 @@ CONTINUE:
} else if (tok_ptr->type == SCC_TOK_COMMA) {
scc_parser_next_consume(parser, nullptr);
if (decl_list == nullptr) {
decl_list = SCC_AST_ALLOC_DECL(parser->ast_ctx);
decl_list = SCC_AST_ALLOC_DECL(parser->ast_module);
Assert(decl_list != nullptr);
scc_vec_push(decl_list_vec, decl);
} else {
@@ -365,7 +365,9 @@ CONTINUE:
}
RETURN:
scc_vec_free(decl_list_vec);
return decl;
ERROR:
scc_vec_free(decl_list_vec);
return nullptr;
}

50
libs/parser/src/parse_expr.c
View File

@@ -371,7 +371,7 @@ static scc_ast_expr_t *parse_expression_with_precedence(scc_parser_t *parser,
return nullptr;
}
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(expr != nullptr);
// FIXME pos
scc_ast_expr_binary_init(expr, op, left, right, left->base.loc);
@@ -410,7 +410,7 @@ scc_ast_expr_t *scc_parse_assignment_expression(scc_parser_t *parser) {
return nullptr;
}
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(expr != nullptr);
scc_ast_expr_binary_init(expr, op, left, right, pos);
left = expr;
@@ -456,7 +456,7 @@ static scc_ast_expr_t *parse_conditional_expression(scc_parser_t *parser) {
return nullptr;
}
scc_ast_expr_t *cond = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
scc_ast_expr_t *cond = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(cond != nullptr);
scc_ast_expr_cond_init(cond, cond_expr, then_expr, else_expr, pos);
cond_expr = cond;
@@ -481,13 +481,13 @@ static scc_ast_expr_t *parse_cast_expression(scc_parser_t *parser) {
scc_ast_expr_t *operand = parse_cast_expression(parser);
if (!operand) {
// FIXME postfix-expression
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_module);
// FIXME pos
scc_ast_expr_lvalue_init(expr, type, type->base.loc);
operand = scc_parse_initializer(parser, expr);
return operand;
}
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(expr != nullptr);
// FIXME pos
scc_ast_expr_cast_init(expr, type, operand, type->base.loc);
@@ -559,7 +559,7 @@ static scc_ast_expr_t *parse_unary_expression(scc_parser_t *parser) {
return nullptr;
}
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(expr != nullptr);
scc_ast_expr_unary_init(expr, op, operand, pos);
return expr;
@@ -588,7 +588,7 @@ static scc_ast_expr_t *parse_sizeof_expression(scc_parser_t *parser) {
return nullptr;
}
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_module);
if (next->type == SCC_TOK_L_PAREN) {
scc_parser_store(parser);
@@ -643,7 +643,7 @@ static scc_ast_expr_t *parse_postfix_expression(scc_parser_t *parser) {
if (!scc_parser_consume_if(parser, SCC_TOK_R_PAREN)) {
SCC_ERROR(scc_parser_got_current_pos(parser), "Expected ')'");
}
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_module);
scc_ast_expr_lvalue_init(expr, type, pos);
left = scc_parse_initializer(parser, expr);
return left;
@@ -672,7 +672,7 @@ static scc_ast_expr_t *parse_postfix_expression(scc_parser_t *parser) {
parser_sync(parser);
return nullptr;
}
scc_ast_expr_t *subscript = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
scc_ast_expr_t *subscript = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(subscript != nullptr);
scc_ast_expr_array_subscript_init(subscript, left, index, pos);
left = subscript;
@@ -709,7 +709,7 @@ static scc_ast_expr_t *parse_postfix_expression(scc_parser_t *parser) {
return nullptr;
}
}
scc_ast_expr_t *call = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
scc_ast_expr_t *call = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(call != nullptr);
scc_ast_expr_call_init(call, left, &args, pos);
left = call;
@@ -729,9 +729,9 @@ static scc_ast_expr_t *parse_postfix_expression(scc_parser_t *parser) {
parser_sync(parser);
return nullptr;
}
const char *name = scc_str_as_cstr(&ident_tok.lexeme);
const char *name = scc_ast_module_intern(parser->ast_module, scc_str_as_cstr(&ident_tok.lexeme));
scc_ast_expr_t *member = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
scc_ast_expr_t *member = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(member != nullptr);
if (op_tok.type == SCC_TOK_DOT) {
scc_ast_expr_member_init(member, left, name, ident_tok.loc);
@@ -750,7 +750,7 @@ static scc_ast_expr_t *parse_postfix_expression(scc_parser_t *parser) {
if (!scc_parser_next_consume(parser, &op_tok))
return left;
scc_ast_expr_op_t op = map_token_to_unary_op(op_tok.type, false);
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(expr != nullptr);
scc_ast_expr_unary_init(expr, op, left, op_tok.loc);
scc_lexer_tok_drop(&op_tok);
@@ -785,36 +785,36 @@ static scc_ast_expr_t *parse_primary_expression(scc_parser_t *parser) {
case SCC_TOK_IDENT: {
if (!scc_parser_next_consume(parser, &tok))
return nullptr;
expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
expr = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(expr != nullptr);
scc_ast_expr_identifier_init(expr, scc_str_as_cstr(&tok.lexeme),
scc_ast_expr_identifier_init(expr, scc_ast_module_intern(parser->ast_module, scc_str_as_cstr(&tok.lexeme)),
tok.loc);
break;
}
case SCC_TOK_INT_LITERAL: {
if (!scc_parser_next_consume(parser, &tok))
return nullptr;
expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
expr = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(expr != nullptr);
scc_ast_expr_literal_int_init(expr, scc_str_as_cstr(&tok.lexeme), false,
scc_ast_expr_literal_int_init(expr, scc_ast_module_intern(parser->ast_module, scc_str_as_cstr(&tok.lexeme)), false,
tok.loc);
break;
}
case SCC_TOK_FLOAT_LITERAL: {
if (!scc_parser_next_consume(parser, &tok))
return nullptr;
expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
expr = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(expr != nullptr);
scc_ast_expr_literal_float_init(expr, scc_str_as_cstr(&tok.lexeme),
scc_ast_expr_literal_float_init(expr, scc_ast_module_intern(parser->ast_module, scc_str_as_cstr(&tok.lexeme)),
false, tok.loc);
break;
}
case SCC_TOK_CHAR_LITERAL: {
if (!scc_parser_next_consume(parser, &tok))
return nullptr;
expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
expr = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(expr != nullptr);
scc_ast_expr_literal_char_init(expr, scc_str_as_cstr(&tok.lexeme),
scc_ast_expr_literal_char_init(expr, scc_ast_module_intern(parser->ast_module, scc_str_as_cstr(&tok.lexeme)),
false, tok.loc);
break;
}
@@ -835,10 +835,12 @@ static scc_ast_expr_t *parse_primary_expression(scc_parser_t *parser) {
scc_str_append(&string, &tmp);
}
expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
const char *pooled_str = scc_ast_module_intern(parser->ast_module, scc_str_as_cstr(&string));
scc_str_drop(&string);
expr = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(expr != nullptr);
// FIXME loc
scc_ast_expr_literal_string_init(expr, scc_str_as_cstr(&string), true,
scc_ast_expr_literal_string_init(expr, pooled_str, false,
tok.loc);
break;
}
@@ -880,7 +882,7 @@ scc_ast_expr_t *scc_parse_expression(scc_parser_t *parser) {
parser_sync(parser);
return nullptr;
}
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_module);
Assert(expr != nullptr);
scc_ast_expr_binary_init(expr, SCC_AST_OP_COMMA, left, right, pos);
left = expr;

28
libs/parser/src/parse_stmt.c
View File

@@ -83,9 +83,9 @@ static scc_ast_stmt_t *parse_label_statement(scc_parser_t *parser,
Panic("expect stmt");
}
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_module);
Assert(stmt != nullptr);
scc_ast_stmt_label_init(stmt, scc_str_as_cstr(&tok.lexeme), statement, pos);
scc_ast_stmt_label_init(stmt, scc_ast_module_intern(parser->ast_module, scc_str_as_cstr(&tok.lexeme)), statement, pos);
return stmt;
}
@@ -114,7 +114,7 @@ static scc_ast_stmt_t *parse_case_statement(scc_parser_t *parser,
Panic("expect stmt");
}
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_module);
scc_ast_stmt_case_init(stmt, expr, statement, pos);
return stmt;
}
@@ -136,7 +136,7 @@ static scc_ast_stmt_t *parse_default_statement(scc_parser_t *parser,
Panic("expect stmt");
}
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_module);
scc_ast_stmt_default_init(stmt, statement, pos);
return stmt;
}
@@ -168,7 +168,7 @@ static scc_ast_stmt_t *parse_compound_statement(scc_parser_t *parser,
}
scc_sema_stmt(parser, scc_ast_stmt_t_END, nullptr);
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_module);
scc_ast_stmt_compound_init(stmt, &block_items, pos);
return stmt;
}
@@ -188,7 +188,7 @@ static scc_ast_stmt_t *parse_if_statement(scc_parser_t *parser, scc_pos_t pos) {
opt_else = nullptr;
}
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_module);
scc_ast_stmt_if_init(stmt, expression, statement, opt_else, pos);
return stmt;
}
@@ -198,7 +198,7 @@ static scc_ast_stmt_t *parse_switch_statement(scc_parser_t *parser,
if (!scc_parser_consume_if(parser, SCC_TOK_SWITCH)) {
return nullptr;
}
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_module);
stmt->base.type = SCC_AST_STMT_SWITCH;
scc_ast_expr_t *expression = ast_parse_paren_expression(parser);
@@ -216,7 +216,7 @@ static scc_ast_stmt_t *parse_while_statement(scc_parser_t *parser,
if (!scc_parser_consume_if(parser, SCC_TOK_WHILE)) {
return nullptr;
}
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_module);
stmt->base.type = SCC_AST_STMT_WHILE;
scc_ast_expr_t *expression = ast_parse_paren_expression(parser);
@@ -234,7 +234,7 @@ static scc_ast_stmt_t *parse_do_while_statement(scc_parser_t *parser,
if (!scc_parser_consume_if(parser, SCC_TOK_DO)) {
return nullptr;
}
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_module);
stmt->base.type = SCC_AST_STMT_DO_WHILE;
scc_sema_stmt(parser, scc_ast_stmt_t_BEGIN, stmt);
@@ -272,7 +272,7 @@ static scc_ast_stmt_t *parse_for_statement(scc_parser_t *parser,
SCC_ERROR(scc_parser_got_current_pos(parser),
"Expected '(' before like `( expression )` .");
}
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_module);
stmt->base.type = SCC_AST_STMT_FOR;
scc_ast_node_t *init = nullptr;
@@ -314,12 +314,12 @@ static scc_ast_stmt_t *parse_for_statement(scc_parser_t *parser,
static scc_ast_stmt_t *parse_jump_statement(scc_parser_t *parser,
scc_pos_t pos) {
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_module);
if (scc_parser_consume_if(parser, SCC_TOK_GOTO)) {
scc_lexer_tok_t tok = {0};
if (scc_parser_next_consume(parser, &tok)) {
scc_ast_stmt_goto_init(stmt, scc_str_as_cstr(&tok.lexeme), pos);
scc_ast_stmt_goto_init(stmt, scc_ast_module_intern(parser->ast_module, scc_str_as_cstr(&tok.lexeme)), pos);
} else {
SCC_ERROR(scc_parser_got_current_pos(parser),
"Expected label after goto.");
@@ -345,7 +345,7 @@ static scc_ast_stmt_t *parse_expression_statement(scc_parser_t *parser,
scc_pos_t pos) {
if (scc_parser_consume_if(parser, SCC_TOK_SEMICOLON)) {
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_module);
scc_ast_stmt_expr_init(stmt, nullptr, pos);
return stmt;
}
@@ -355,7 +355,7 @@ static scc_ast_stmt_t *parse_expression_statement(scc_parser_t *parser,
return nullptr;
}
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_module);
scc_ast_stmt_expr_init(stmt, expr, pos);
if (!scc_parser_consume_if(parser, SCC_TOK_SEMICOLON)) {

48
libs/parser/src/parse_type.c
View File

@@ -526,9 +526,9 @@ static scc_ast_qual_type_t *build_type_from_info(scc_parser_t *parser,
}
}
scc_ast_ctx_get_builtin_type(parser->ast_ctx, builtin);
scc_ast_qual_type_t *type = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
scc_ast_type_builtin_init(type, parser->ast_ctx, builtin, pos);
scc_ast_module_get_builtin_type(parser->ast_module, builtin);
scc_ast_qual_type_t *type = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_module);
scc_ast_type_builtin_init(type, parser->ast_module, builtin, pos);
return type;
}
@@ -551,7 +551,7 @@ static scc_ast_qual_type_t *parse_record_type(scc_parser_t *parser,
if (tok_ptr->type == SCC_TOK_IDENT) {
scc_parser_next_consume(parser, &tok);
tok_ptr = scc_parser_peek(parser);
name = scc_str_as_cstr(&tok.lexeme);
name = scc_ast_module_intern(parser->ast_module, scc_str_as_cstr(&tok.lexeme));
} else if (tok_ptr->type != SCC_TOK_L_BRACE) {
SCC_ERROR(scc_parser_got_current_pos(parser),
"Expected name in struct/union/enum specifier");
@@ -581,8 +581,8 @@ static scc_ast_qual_type_t *parse_record_type(scc_parser_t *parser,
type = scc_parse_got_type(parser, scc_str_as_cstr(&symbol_name));
if (type == nullptr) {
scc_ast_canon_type_t *canon = scc_ast_ctx_alloc_type(parser->ast_ctx);
scc_ast_decl_t *decl = SCC_AST_ALLOC_DECL(parser->ast_ctx);
scc_ast_canon_type_t *canon = scc_ast_module_alloc_type(parser->ast_module);
scc_ast_decl_t *decl = SCC_AST_ALLOC_DECL(parser->ast_module);
scc_ast_node_kind_t decl_kind;
switch (type_kind) {
@@ -607,7 +607,7 @@ static scc_ast_qual_type_t *parse_record_type(scc_parser_t *parser,
}
scc_ast_qual_type_t *qual_type =
SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
SCC_AST_ALLOC_QUAL_TYPE(parser->ast_module);
_scc_ast_type_record_init(qual_type, canon, type_kind, name, decl,
*pos);
scc_parse_type_sema(parser, qual_type);
@@ -747,10 +747,10 @@ static scc_ast_qual_type_t *parse_enum_type(scc_parser_t *parser) {
}
scc_ast_decl_t *enum_item_decl =
SCC_AST_ALLOC_DECL(parser->ast_ctx);
SCC_AST_ALLOC_DECL(parser->ast_module);
Assert(enum_item_decl != nullptr);
scc_ast_decl_val_init(enum_item_decl, type,
scc_str_as_cstr(&tok.lexeme), enum_item_init,
scc_ast_module_intern(parser->ast_module, scc_str_as_cstr(&tok.lexeme)), enum_item_init,
tok.loc);
scc_vec_push(decl->record.fields, enum_item_decl);
@@ -939,14 +939,14 @@ parse_pointer(scc_parser_t *parser, scc_ast_qual_type_t *pointee,
scc_pos_t pos = tok_ptr->loc;
scc_parser_next_consume(parser, nullptr);
scc_ast_qual_type_t *pointer = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
scc_ast_qual_type_t *pointer = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_module);
if (pointee == nullptr) {
Assert(delay_pointee_ptr != nullptr);
*delay_pointee_ptr = pointer;
pointee = pointer;
}
scc_ast_canon_type_t *canon = scc_ast_ctx_alloc_type(parser->ast_ctx);
scc_ast_canon_type_t *canon = scc_ast_module_alloc_type(parser->ast_module);
scc_ast_type_pointer_init(pointer, canon, pointee, pos);
pointer->quals = parse_type_qualifier_list(parser, pointer->quals);
@@ -981,7 +981,7 @@ static void parse_parameter_type_list(scc_parser_t *parser,
}
// TODO Check validation
param = SCC_AST_ALLOC_DECL(parser->ast_ctx);
param = SCC_AST_ALLOC_DECL(parser->ast_module);
Assert(param != nullptr);
scc_ast_decl_param_init(param, decl->var.type, decl->name,
scc_vec_size(*params), decl->base.loc);
@@ -998,11 +998,11 @@ static void parse_parameter_type_list(scc_parser_t *parser,
scc_parser_next_consume(parser, nullptr);
tok_ptr = scc_parser_peek(parser);
if (tok_ptr->type == SCC_TOK_ELLIPSIS) {
param = SCC_AST_ALLOC_DECL(parser->ast_ctx);
param = SCC_AST_ALLOC_DECL(parser->ast_module);
Assert(param != nullptr);
// FIXME
type = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
scc_ast_type_builtin_init(type, parser->ast_ctx,
type = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_module);
scc_ast_type_builtin_init(type, parser->ast_module,
SCC_AST_BUILTIN_TYPE_VA_LIST,
tok_ptr->loc);
scc_ast_decl_param_init(param, type, nullptr, scc_vec_size(*params),
@@ -1112,7 +1112,7 @@ parse_direct_declarator(scc_parser_t *parser, scc_ast_qual_type_t *base,
scc_lexer_tok_t *tok_ident) {
const scc_lexer_tok_t *tok_ptr = nullptr;
scc_ast_qual_type_t *ret = nullptr;
scc_ast_canon_type_t *canon = scc_ast_ctx_alloc_type(parser->ast_ctx);
scc_ast_canon_type_t *canon = scc_ast_module_alloc_type(parser->ast_module);
// direct-abstract-declarator
tok_ptr = scc_parser_peek(parser);
if (tok_ptr == nullptr) {
@@ -1137,7 +1137,7 @@ parse_direct_declarator(scc_parser_t *parser, scc_ast_qual_type_t *base,
if (parse_function_parameters_start(parser)) {
scc_ast_decl_vec_t params;
parse_function_parameters(parser, &params);
ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_module);
// FIXME
scc_ast_type_function_init(ret, canon, base, &params,
base->base.loc);
@@ -1162,7 +1162,7 @@ parse_direct_declarator(scc_parser_t *parser, scc_ast_qual_type_t *base,
} else if (tok_ptr->type == SCC_TOK_L_BRACKET) {
// [] SCC_TOK_L_BRACKET
scc_ast_expr_t *size = parse_array_size_type(parser);
scc_ast_qual_type_t *ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
scc_ast_qual_type_t *ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_module);
base =
parse_direct_declarator(parser, base, delay_pointee_ptr, tok_ident);
// FIXME
@@ -1202,7 +1202,7 @@ parse_direct_abstract_declarator(scc_parser_t *parser,
scc_ast_qual_type_t **delay_pointee_ptr) {
const scc_lexer_tok_t *tok_ptr = nullptr;
scc_ast_qual_type_t *ret = nullptr;
scc_ast_canon_type_t *canon = scc_ast_ctx_alloc_type(parser->ast_ctx);
scc_ast_canon_type_t *canon = scc_ast_module_alloc_type(parser->ast_module);
// direct-abstract-declarator
tok_ptr = scc_parser_peek(parser);
if (tok_ptr == nullptr) {
@@ -1216,7 +1216,7 @@ parse_direct_abstract_declarator(scc_parser_t *parser,
if (parse_function_parameters_start(parser)) {
scc_ast_decl_vec_t params;
parse_function_parameters(parser, &params);
ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_module);
// FIXME
scc_ast_type_function_init(ret, canon, base, &params,
base->base.loc);
@@ -1237,7 +1237,7 @@ parse_direct_abstract_declarator(scc_parser_t *parser,
} else if (tok_ptr->type == SCC_TOK_L_BRACKET) {
// [] SCC_TOK_L_BRACKET
scc_ast_expr_t *size = parse_array_size_type(parser);
scc_ast_qual_type_t *ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
scc_ast_qual_type_t *ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_module);
base =
parse_direct_abstract_declarator(parser, base, delay_pointee_ptr);
// FIXME
@@ -1254,14 +1254,14 @@ scc_ast_decl_t *scc_parse_declarator(scc_parser_t *parser,
scc_ast_qual_type_t *decl_type =
parse_declarator(parser, type, nullptr, &decl_name_tok);
scc_ast_decl_t *decl = nullptr;
decl = SCC_AST_ALLOC_DECL(parser->ast_ctx);
decl = SCC_AST_ALLOC_DECL(parser->ast_module);
Assert(decl != nullptr);
Assert(decl_name_tok.type == SCC_TOK_IDENT ||
decl_name_tok.type == SCC_TOK_UNKNOWN);
// FIXME memory leak
const char *name = decl_name_tok.type == SCC_TOK_IDENT
? scc_str_as_cstr(&decl_name_tok.lexeme)
? scc_ast_module_intern(parser->ast_module, scc_str_as_cstr(&decl_name_tok.lexeme))
: nullptr;
if (decl_type->base.type == SCC_AST_TYPE_FUNCTION) {
@@ -1288,7 +1288,7 @@ scc_ast_decl_t *scc_parse_declarator(scc_parser_t *parser,
// decl = scc_ast_canon_type(decl_type)->record.decl;
// } else {
// // TODO();
// // decl = SCC_AST_ALLOC_DECL(parser->ast_ctx);
// // decl = SCC_AST_ALLOC_DECL(parser->ast_module);
// // scc_ast_decl_unsafe_val_init(decl, type, nullptr, nullptr,
// // decl_type->base.loc);
// }

6
libs/parser/src/scc_parser.c
View File

@@ -20,10 +20,10 @@ static scc_ast_qual_type_t *dummy_got_type_callback(scc_sema_ctx_t *context,
assigned_val = value ? value : default
void scc_parser_init(scc_parser_t *parser, scc_lexer_tok_ring_t *tok_ring,
scc_ast_ctx_t *ast_ctx, scc_sema_ctx_t *sema_ctx) {
scc_ast_module_t *ast_module, scc_sema_ctx_t *sema_ctx) {
Assert(parser != nullptr && tok_ring != nullptr);
Assert(ast_ctx != nullptr);
parser->ast_ctx = ast_ctx;
Assert(ast_module != nullptr);
parser->ast_module = ast_module;
parser->ring = tok_ring;
parser->errcode = 0;

26
libs/parser/src/scc_sema.c
View File

@@ -31,14 +31,15 @@ static void symtab_add_symbol(scc_sema_symtab_t *sema_symtab,
if (decl->name == nullptr)
return;
// FIXME memory leak
scc_str_t name = scc_str_empty();
gen_symbol_name(decl, &name);
if (scc_str_is_empty(&name)) {
scc_sema_symtab_add_symbol(sema_symtab, decl->name, ast_node_ref);
} else {
scc_sema_symtab_add_symbol(sema_symtab, scc_str_as_cstr(&name),
ast_node_ref);
const char *pooled = scc_strpool_intern(&sema_symtab->name_pool,
scc_str_as_cstr(&name));
scc_sema_symtab_add_symbol(sema_symtab, pooled, ast_node_ref);
scc_str_drop(&name);
}
}
@@ -291,8 +292,8 @@ static scc_ast_qual_type_t *got_type_callback(scc_sema_ctx_t *sema_ctx,
return nullptr;
}
void scc_sema_init(scc_sema_ctx_t *sema_ctx, scc_ast_ctx_t *ast_ctx) {
sema_ctx->ast_ctx = ast_ctx;
void scc_sema_init(scc_sema_ctx_t *sema_ctx, scc_ast_module_t *ast_module) {
sema_ctx->ast_module = ast_module;
scc_sema_symtab_t *sema_symtab = scc_malloc(sizeof(scc_sema_symtab_t));
if (sema_symtab == nullptr) {
LOG_FATAL("out of memory");
@@ -311,25 +312,23 @@ void scc_sema_init(scc_sema_ctx_t *sema_ctx, scc_ast_ctx_t *ast_ctx) {
scc_vec_init(sema_ctx->break_stack);
scc_vec_init(sema_ctx->continue_stack);
// FIXME memory leak
scc_ast_qual_type_t *type = SCC_AST_ALLOC_QUAL_TYPE(sema_ctx->ast_ctx);
scc_ast_type_builtin_init(type, sema_ctx->ast_ctx,
scc_ast_qual_type_t *type = SCC_AST_ALLOC_QUAL_TYPE(sema_ctx->ast_module);
scc_ast_type_builtin_init(type, sema_ctx->ast_module,
SCC_AST_BUILTIN_TYPE_VA_LIST, scc_pos_create());
scc_sema_symtab_add_symbol(sema_symtab, "__scc_builtin_va_list",
&type->base);
scc_ast_decl_t *decl = SCC_AST_ALLOC_DECL(sema_ctx->ast_ctx);
scc_ast_decl_t *decl = SCC_AST_ALLOC_DECL(sema_ctx->ast_module);
scc_ast_decl_val_init(decl, type, "__scc_builtin__", nullptr,
scc_pos_create());
scc_sema_symtab_add_symbol(sema_symtab, "__func__", &decl->base);
scc_ast_qual_type_t *built_func_type =
SCC_AST_ALLOC_QUAL_TYPE(sema_ctx->ast_ctx);
SCC_AST_ALLOC_QUAL_TYPE(sema_ctx->ast_module);
// FIXME hack
built_func_type->base.type = SCC_AST_TYPE_FUNCTION;
scc_ast_decl_t *builin_func = SCC_AST_ALLOC_DECL(sema_ctx->ast_ctx);
scc_ast_decl_t *builin_func = SCC_AST_ALLOC_DECL(sema_ctx->ast_module);
scc_ast_decl_func_init(builin_func, built_func_type, "__scc_builtin_func",
nullptr, scc_pos_create());
scc_sema_symtab_add_symbol(sema_symtab, "__scc_builtin_va_start",
@@ -348,8 +347,9 @@ void scc_sema_drop(scc_sema_ctx_t *sema_ctx) {
scc_vec_free(sema_ctx->break_stack);
scc_vec_free(sema_ctx->continue_stack);
// FIXME drop obj
if (sema_ctx->context) {
scc_sema_symtab_drop(sema_ctx->context);
scc_free(sema_ctx->context);
sema_ctx->context = nullptr;
}
}

10
libs/parser/src/sema_symtab.c
View File

@@ -5,13 +5,19 @@ void scc_sema_symtab_init(scc_sema_symtab_t *symtab) {
scc_hashtable_cstr_init(&symtab->root_scope.symbols);
symtab->current_scope = &symtab->root_scope;
scc_strpool_init(&symtab->name_pool);
}
void scc_sema_symtab_drop(scc_sema_symtab_t *symtab) {
while (symtab->current_scope != nullptr) {
scc_hashtable_drop(&symtab->current_scope->symbols);
scc_sema_scope_t *scope = symtab->current_scope;
symtab->current_scope = symtab->current_scope->parent;
if (scope != &symtab->root_scope) {
scc_free(scope);
}
}
scc_strpool_drop(&symtab->name_pool);
}
void scc_sema_symtab_enter_scope(scc_sema_symtab_t *symtab) {
@@ -30,8 +36,10 @@ void scc_sema_symtab_leave_scope(scc_sema_symtab_t *symtab) {
LOG_ERROR("out of scope");
return;
}
scc_hashtable_drop(&symtab->current_scope->symbols);
scc_sema_scope_t *scope = symtab->current_scope;
scc_hashtable_drop(&scope->symbols);
symtab->current_scope = symtab->current_scope->parent;
scc_free(scope);
}
scc_ast_node_t *scc_sema_symtab_add_symbol(scc_sema_symtab_t *symtab,