diff --git a/libs/abi/include/scc_type_abi.h b/libs/abi/include/scc_type_abi.h index 1829d5b..3776475 100644 --- a/libs/abi/include/scc_type_abi.h +++ b/libs/abi/include/scc_type_abi.h @@ -17,6 +17,7 @@ */ typedef enum scc_abi_base_type_kind { SCC_ABI_TYPE_VOID, + SCC_ABI_TYPE_VA_LIST, SCC_ABI_TYPE_CHAR, SCC_ABI_TYPE_I_CHAR, SCC_ABI_TYPE_U_CHAR, diff --git a/libs/abi/include/target/scc_abi_win_x64_pc.h b/libs/abi/include/target/scc_abi_win_x64_pc.h index 95d79c7..8ca7e26 100644 --- a/libs/abi/include/target/scc_abi_win_x64_pc.h +++ b/libs/abi/include/target/scc_abi_win_x64_pc.h @@ -9,6 +9,15 @@ #include "../scc_type_abi.h" static const scc_abi_base_type_impl_t scc_abi_base_type_impls[] = { + /** + * @brief + * https://learn.microsoft.com/zh-cn/cpp/build/x64-calling-convention?view=msvc-180#varargs + * 如果通过 vararg (例如省略号参数) 传递参数,则需遵守常规寄存器参数传递约定. + * 该约定规定了将第 5个及后面的参数溢出到堆栈中. + * 被调用方负责转储带有其地址的参数. + * (仅适用于浮点值)如果被调用方希望在整数寄存器中使用浮点值,则整数寄存器和浮点数寄存器都必须包含该值. + */ + SCC_ABI_BASE_TYPE_IMPL(SCC_ABI_TYPE_VA_LIST, 4, 4), SCC_ABI_BASE_TYPE_IMPL(SCC_ABI_TYPE_VOID, 0, 0), SCC_ABI_BASE_TYPE_IMPL(SCC_ABI_TYPE_CHAR, 1, 1), SCC_ABI_BASE_TYPE_IMPL(SCC_ABI_TYPE_I_CHAR, 1, 1), diff --git a/libs/abi/src/scc_type_abi.c b/libs/abi/src/scc_type_abi.c index 223df7e..949e1af 100644 --- a/libs/abi/src/scc_type_abi.c +++ b/libs/abi/src/scc_type_abi.c @@ -7,6 +7,12 @@ void scc_abi_compute_ast_type_layout(const scc_abi_type_calc_t *ctx, void *type, scc_ast_qual_type_t *ast_type = type; scc_abi_base_type_kind_t kind = SCC_ABI_TYPE_VOID; switch (scc_ast_canon_type(ast_type)->builtin.type) { + case SCC_AST_BUILTIN_TYPE_VA_LIST: + kind = SCC_ABI_TYPE_VA_LIST; + break; + case SCC_AST_BUILTIN_TYPE_BOOL: + kind = SCC_ABI_TYPE_I_INT; + break; case SCC_AST_BUILTIN_TYPE_VOID: kind = SCC_ABI_TYPE_VOID; break; diff --git a/libs/ast/src/ast_dump.c b/libs/ast/src/ast_dump.c index ea0251e..9200115 100644 --- a/libs/ast/src/ast_dump.c +++ b/libs/ast/src/ast_dump.c @@ -511,14 +511,22 @@ static void dump_decl_impl(scc_tree_dump_t *td, const scc_ast_decl_t *decl) { i + 1 == scc_vec_size(decl->list.vars)); } break; - case SCC_AST_DECL_VAR: + case SCC_AST_DECL_VAR: { if (decl->var.type) { - dump_child_node(td, (scc_ast_node_t *)decl->var.type, - decl->var.init == nullptr); + scc_ast_qual_type_t *type = decl->var.type; + dump_child_node(td, &type->base, decl->var.init == nullptr); + // if ((type->base.type == SCC_AST_TYPE_STRUCT || + // type->base.type == SCC_AST_TYPE_ENUM || + // type->base.type == SCC_AST_TYPE_UNION) && + // scc_ast_canon_type(type)->record.decl) { + // dump_child_node( + // td, (scc_ast_node_t + // *)scc_ast_canon_type(type)->record.decl, true); + // } if (decl->var.init) dump_child_node(td, (scc_ast_node_t *)decl->var.init, true); } - break; + } break; case SCC_AST_DECL_FUNC: if (decl->func.type) { dump_child_node(td, (scc_ast_node_t *)decl->func.type, diff --git a/libs/ast2ir/include/scc_ast2ir.h b/libs/ast2ir/include/scc_ast2ir.h index 9da4243..b2d7a79 100644 --- a/libs/ast2ir/include/scc_ast2ir.h +++ b/libs/ast2ir/include/scc_ast2ir.h @@ -7,8 +7,10 @@ typedef struct { scc_hir_builder_t builder; - scc_hashtable_t ast2ir_cache; ///< ast node to ir ref cache - scc_hashtable_t symtab; ///< symbol to ir_ref + scc_hashtable_t ast2ir_cache; ///< ast node to ir ref cache + scc_hashtable_t break_cache; ///< break cache + scc_hashtable_t continue_cache; ///< continue cache + scc_hashtable_t symtab; ///< symbol to ir_ref // scc_strpool_t strpool; ///< string pool const scc_abi_type_calc_t *abi; cbool hint_using_value; // 转换时尽可能使用value而不是alloc diff --git a/libs/ast2ir/src/scc_ast2ir.c b/libs/ast2ir/src/scc_ast2ir.c index 220b80f..ff35174 100644 --- a/libs/ast2ir/src/scc_ast2ir.c +++ b/libs/ast2ir/src/scc_ast2ir.c @@ -626,8 +626,7 @@ scc_hir_value_ref_t scc_ast2ir_expr(scc_ast2ir_ctx_t *ctx, // &ctx->builder, scc_hir_builder_type_u64(&ctx->builder), val); } case SCC_AST_EXPR_COMPOUND: { - break; - } + } break; case SCC_AST_EXPR_LVALUE: break; // SCC_AST_EXPR_BUILTIN,// 内置表达式 ... directive map to ir builtin @@ -793,6 +792,9 @@ void scc_ast2ir_stmt(scc_ast2ir_ctx_t *ctx, const scc_ast_stmt_t *stmt) { scc_hir_value_ref_t exit_block = scc_hir_builder_bblock(&ctx->builder, "while_exit"); + scc_hashtable_set(&ctx->break_cache, stmt, (void *)exit_block); + scc_hashtable_set(&ctx->continue_cache, stmt, (void *)cond_block); + scc_hir_builder_jump(&ctx->builder, cond_block); scc_hir_builder_set_current_bblock(&ctx->builder, cond_block); @@ -816,6 +818,9 @@ void scc_ast2ir_stmt(scc_ast2ir_ctx_t *ctx, const scc_ast_stmt_t *stmt) { scc_hir_value_ref_t exit_block = scc_hir_builder_bblock(&ctx->builder, "do_while_exit"); + scc_hashtable_set(&ctx->break_cache, stmt, (void *)exit_block); + scc_hashtable_set(&ctx->continue_cache, stmt, (void *)cond_block); + scc_hir_builder_jump(&ctx->builder, body_block); scc_hir_builder_set_current_bblock(&ctx->builder, body_block); @@ -833,11 +838,16 @@ void scc_ast2ir_stmt(scc_ast2ir_ctx_t *ctx, const scc_ast_stmt_t *stmt) { } case SCC_AST_STMT_FOR: { scc_hir_value_ref_t cond_block = - scc_hir_builder_bblock(&ctx->builder, "for_while_cond"); + scc_hir_builder_bblock(&ctx->builder, "for_cond"); scc_hir_value_ref_t body_block = - scc_hir_builder_bblock(&ctx->builder, "for_while_body"); + scc_hir_builder_bblock(&ctx->builder, "for_body"); + scc_hir_value_ref_t incr_block = + scc_hir_builder_bblock(&ctx->builder, "for_incr"); scc_hir_value_ref_t exit_block = - scc_hir_builder_bblock(&ctx->builder, "for_while_exit"); + scc_hir_builder_bblock(&ctx->builder, "for_exit"); + + scc_hashtable_set(&ctx->break_cache, stmt, (void *)exit_block); + scc_hashtable_set(&ctx->continue_cache, stmt, (void *)incr_block); if (stmt->for_stmt.init) { if (SCC_AST_IS_A(scc_ast_decl_t, stmt->for_stmt.init)) { @@ -867,10 +877,13 @@ void scc_ast2ir_stmt(scc_ast2ir_ctx_t *ctx, const scc_ast_stmt_t *stmt) { scc_hir_builder_set_current_bblock(&ctx->builder, body_block); scc_ast2ir_stmt(ctx, stmt->for_stmt.body); + scc_hir_builder_jump(&ctx->builder, incr_block); + + scc_hir_builder_set_current_bblock(&ctx->builder, incr_block); if (stmt->for_stmt.incr) { scc_ast2ir_expr(ctx, stmt->for_stmt.incr, false); } - scc_hir_builder_jump(&ctx->builder, cond_block); + scc_hir_builder_jump(&ctx->builder, exit_block); scc_hir_builder_set_current_bblock(&ctx->builder, exit_block); break; @@ -878,8 +891,18 @@ void scc_ast2ir_stmt(scc_ast2ir_ctx_t *ctx, const scc_ast_stmt_t *stmt) { // SCC_AST_STMT_SWITCH, // switch 语句 // SCC_AST_STMT_CASE, // case 语句 // SCC_AST_STMT_DEFAULT, // default 语句 - // SCC_AST_STMT_BREAK, // break 语句 - // SCC_AST_STMT_CONTINUE, // continue 语句 + case SCC_AST_STMT_BREAK: { + scc_hir_bblock_ref_t target = + (usize)scc_hashtable_get(&ctx->break_cache, stmt->jump._target); + Assert(target != SCC_HIR_REF_nullptr); + scc_hir_builder_jump(&ctx->builder, target); + } break; + case SCC_AST_STMT_CONTINUE: { + scc_hir_bblock_ref_t target = + (usize)scc_hashtable_get(&ctx->continue_cache, stmt->jump._target); + Assert(target != SCC_HIR_REF_nullptr); + scc_hir_builder_jump(&ctx->builder, target); + } break; case SCC_AST_STMT_RETURN: { if (stmt->return_stmt.expr) { scc_hir_value_ref_t ret_val_node = @@ -890,8 +913,19 @@ void scc_ast2ir_stmt(scc_ast2ir_ctx_t *ctx, const scc_ast_stmt_t *stmt) { } break; } - // SCC_AST_STMT_GOTO, // goto 语句 - // SCC_AST_STMT_LABEL, // 标签语句 + case SCC_AST_STMT_GOTO: { + scc_hir_bblock_ref_t target = (usize)scc_hashtable_get( + &ctx->ast2ir_cache, (void *)stmt->goto_stmt._target); + Assert(target != SCC_HIR_REF_nullptr); + scc_hir_builder_jump(&ctx->builder, target); + } break; + case SCC_AST_STMT_LABEL: { + scc_hir_value_ref_t label_block = + scc_hir_builder_bblock(&ctx->builder, stmt->label_stmt.label); + scc_hir_builder_set_current_bblock(&ctx->builder, label_block); + scc_hashtable_set(&ctx->ast2ir_cache, stmt, (void *)label_block); + scc_ast2ir_stmt(ctx, stmt->label_stmt.stmt); + } break; default: LOG_FATAL("Unsupported statement type: %d", stmt->base.type); break; @@ -1039,7 +1073,7 @@ void scc_ast2ir_decl(scc_ast2ir_ctx_t *ctx, const scc_ast_decl_t *decl, break; } case SCC_AST_DECL_STRUCT: - case SCC_AST_DECL_UNION: + case SCC_AST_DECL_UNION: { scc_ast_canon_type_t canon_type = { .record.decl = decl, .record.name = decl->name, @@ -1052,8 +1086,8 @@ void scc_ast2ir_decl(scc_ast2ir_ctx_t *ctx, const scc_ast_decl_t *decl, scc_hir_type_ref_t type_ref = scc_ast2ir_type(ctx, &type); // scc_hir_builder_global_alloca(&ctx->builder, type_ref, // SCC_HIR_REF_nullptr); - break; - case SCC_AST_DECL_ENUM: + } break; + case SCC_AST_DECL_ENUM: { scc_ap_t val; int idx = 0; scc_ap_set_int(&val, idx); @@ -1070,7 +1104,7 @@ void scc_ast2ir_decl(scc_ast2ir_ctx_t *ctx, const scc_ast_decl_t *decl, (void *)(usize)item_val_ref); scc_ap_set_int(&val, ++idx); } - break; + } break; case SCC_AST_DECL_TYPEDEF: break; default: @@ -1095,6 +1129,8 @@ void scc_ast2ir_ctx_init(scc_ast2ir_ctx_t *ctx, const scc_abi_type_calc_t *abi, ctx->abi = abi; scc_hir_builder_init(&ctx->builder, cprog); scc_hashtable_usize_init(&ctx->ast2ir_cache); + scc_hashtable_usize_init(&ctx->break_cache); + scc_hashtable_usize_init(&ctx->continue_cache); scc_hashtable_cstr_init(&ctx->symtab); ctx->hint_using_value = false; } @@ -1102,5 +1138,7 @@ void scc_ast2ir_ctx_init(scc_ast2ir_ctx_t *ctx, const scc_abi_type_calc_t *abi, void scc_ast2ir_ctx_drop(scc_ast2ir_ctx_t *ctx) { scc_hir_builder_drop(&ctx->builder); scc_hashtable_drop(&ctx->ast2ir_cache); + scc_hashtable_drop(&ctx->break_cache); + scc_hashtable_drop(&ctx->continue_cache); scc_hashtable_drop(&ctx->symtab); } diff --git a/libs/parser/include/scc_parser.h b/libs/parser/include/scc_parser.h index 28c7737..8730f7e 100644 --- a/libs/parser/include/scc_parser.h +++ b/libs/parser/include/scc_parser.h @@ -15,7 +15,8 @@ typedef struct scc_parser { usize checkpoint; scc_ast_ctx_t *ast_ctx; - scc_sema_ctx_t sema_callbacks; + scc_sema_ctx_t *sema_ctx; + int owned_sema; scc_ast_translation_unit_t *translation_unit; int errcode; } scc_parser_t; @@ -79,38 +80,49 @@ scc_ast_decl_t *scc_parse_declarator(scc_parser_t *parser, scc_ast_qual_type_t *scc_parse_declaration_specifiers(scc_parser_t *parser); scc_ast_qual_type_t *scc_parse_type_name(scc_parser_t *parser); +static inline void scc_sema_decl(scc_parser_t *parser, scc_ast_node_kind_t kind, + scc_ast_decl_t *decl) { + parser->sema_ctx->on_decl(parser->sema_ctx, kind, decl); +} + +static inline void scc_sema_expr(scc_parser_t *parser, scc_ast_node_kind_t kind, + scc_ast_expr_t *expr) { + parser->sema_ctx->on_expr(parser->sema_ctx, kind, expr); +} + +static inline void scc_sema_stmt(scc_parser_t *parser, scc_ast_node_kind_t kind, + scc_ast_stmt_t *stmt) { + parser->sema_ctx->on_stmt(parser->sema_ctx, kind, stmt); +} + +static inline void scc_sema_type(scc_parser_t *parser, scc_ast_node_kind_t kind, + scc_ast_qual_type_t *type) { + parser->sema_ctx->on_type(parser->sema_ctx, kind, type); +} + static inline void scc_parse_decl_sema(scc_parser_t *parser, scc_ast_decl_t *decl) { - parser->sema_callbacks.on_decl(parser->sema_callbacks.context, - decl ? decl->base.type : SCC_AST_UNKNOWN, - decl); + scc_sema_decl(parser, decl ? decl->base.type : SCC_AST_UNKNOWN, decl); } static inline void scc_parse_expr_sema(scc_parser_t *parser, scc_ast_expr_t *expr) { - parser->sema_callbacks.on_expr(parser->sema_callbacks.context, - expr ? expr->base.type : SCC_AST_UNKNOWN, - expr); + scc_sema_expr(parser, expr ? expr->base.type : SCC_AST_UNKNOWN, expr); } static inline void scc_parse_stmt_sema(scc_parser_t *parser, scc_ast_stmt_t *stmt) { - parser->sema_callbacks.on_stmt(parser->sema_callbacks.context, - stmt ? stmt->base.type : SCC_AST_UNKNOWN, - stmt); + scc_sema_stmt(parser, stmt ? stmt->base.type : SCC_AST_UNKNOWN, stmt); } static inline void scc_parse_type_sema(scc_parser_t *parser, scc_ast_qual_type_t *type) { - parser->sema_callbacks.on_type(parser->sema_callbacks.context, - type ? type->base.type : SCC_AST_UNKNOWN, - type); + scc_sema_type(parser, type ? type->base.type : SCC_AST_UNKNOWN, type); } static inline const scc_ast_qual_type_t * scc_parse_got_type(scc_parser_t *parser, const char *name) { - return parser->sema_callbacks.got_type(parser->sema_callbacks.context, - name); + return parser->sema_ctx->got_type(parser->sema_ctx, name); } #endif /* __SCC_PARSER_H__ */ diff --git a/libs/parser/include/scc_sema.h b/libs/parser/include/scc_sema.h index bc3b426..29579da 100644 --- a/libs/parser/include/scc_sema.h +++ b/libs/parser/include/scc_sema.h @@ -3,27 +3,31 @@ #include +typedef struct scc_sema_ctx scc_sema_ctx_t; /** * @brief 语义分析回调函数类型 */ -typedef void (*scc_sema_callback_t)(void *context, +typedef void (*scc_sema_callback_t)(scc_sema_ctx_t *context, scc_ast_node_kind_t node_type, void *node); -typedef const scc_ast_qual_type_t *(*scc_sema_got_type_t)(void *context, - const char *name); +typedef const scc_ast_qual_type_t *(*scc_sema_got_type_t)( + scc_sema_ctx_t *context, const char *name); /** * @brief 语义分析回调集合 */ -typedef struct scc_sema_ctx { +struct scc_sema_ctx { scc_sema_callback_t on_decl; scc_sema_callback_t on_stmt; 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_stmt_vec_t break_stack; + scc_ast_stmt_vec_t continue_stack; void *context; -} scc_sema_ctx_t; +}; void scc_sema_init(scc_sema_ctx_t *sema_ctx, scc_ast_ctx_t *ast_ctx); void scc_sema_drop(scc_sema_ctx_t *sema_ctx); diff --git a/libs/parser/src/parse_decl.c b/libs/parser/src/parse_decl.c index 8cfc872..d0b85f2 100644 --- a/libs/parser/src/parse_decl.c +++ b/libs/parser/src/parse_decl.c @@ -290,8 +290,7 @@ CONTINUE: decl->var.init = scc_parse_initializer(parser, lvalue); } else if (tok_ptr->type == SCC_TOK_L_BRACE) { scc_parse_decl_sema(parser, decl); - parser->sema_callbacks.on_decl(parser->sema_callbacks.context, - scc_ast_decl_t_BEGIN, nullptr); + scc_sema_decl(parser, scc_ast_decl_t_BEGIN, nullptr); // FIXME hack struct scc_vec_foreach(decl->func.type->type->function.params, i) { scc_ast_decl_t *param = @@ -300,8 +299,7 @@ CONTINUE: scc_parse_decl_sema(parser, param); } scc_ast_stmt_t *body = scc_parse_statement(parser); - parser->sema_callbacks.on_decl(parser->sema_callbacks.context, - scc_ast_decl_t_END, nullptr); + scc_sema_decl(parser, scc_ast_decl_t_END, nullptr); Assert(decl->base.type == SCC_AST_DECL_FUNC); decl->func.body = body; Assert(decl->func.type != nullptr); diff --git a/libs/parser/src/parse_stmt.c b/libs/parser/src/parse_stmt.c index 61bfa6d..7345a62 100644 --- a/libs/parser/src/parse_stmt.c +++ b/libs/parser/src/parse_stmt.c @@ -149,8 +149,7 @@ static scc_ast_stmt_t *parse_compound_statement(scc_parser_t *parser, scc_ast_block_item_vec_t block_items; scc_vec_init(block_items); - parser->sema_callbacks.on_stmt(parser->sema_callbacks.context, - scc_ast_stmt_t_BEGIN, nullptr); + scc_sema_stmt(parser, scc_ast_stmt_t_BEGIN, nullptr); while (!scc_parser_consume_if(parser, SCC_TOK_R_BRACE)) { /// TODO // scc_parse_is_decl(); @@ -167,8 +166,7 @@ static scc_ast_stmt_t *parse_compound_statement(scc_parser_t *parser, } scc_vec_push(block_items, ret); } - parser->sema_callbacks.on_stmt(parser->sema_callbacks.context, - scc_ast_stmt_t_END, nullptr); + 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_compound_init(stmt, &block_items, pos); @@ -200,11 +198,15 @@ 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); + stmt->base.type = SCC_AST_STMT_SWITCH; scc_ast_expr_t *expression = ast_parse_paren_expression(parser); - scc_ast_stmt_t *statement = scc_parse_statement(parser); - scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx); + scc_sema_stmt(parser, scc_ast_stmt_t_BEGIN, stmt); + scc_ast_stmt_t *statement = scc_parse_statement(parser); + scc_sema_stmt(parser, scc_ast_stmt_t_END, stmt); + scc_ast_stmt_switch_init(stmt, expression, statement, pos); return stmt; } @@ -214,11 +216,15 @@ 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); + stmt->base.type = SCC_AST_STMT_WHILE; scc_ast_expr_t *expression = ast_parse_paren_expression(parser); - scc_ast_stmt_t *statement = scc_parse_statement(parser); - scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx); + scc_sema_stmt(parser, scc_ast_stmt_t_BEGIN, stmt); + scc_ast_stmt_t *statement = scc_parse_statement(parser); + scc_sema_stmt(parser, scc_ast_stmt_t_END, stmt); + scc_ast_stmt_while_init(stmt, expression, statement, pos); return stmt; } @@ -228,8 +234,12 @@ 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); + stmt->base.type = SCC_AST_STMT_DO_WHILE; + scc_sema_stmt(parser, scc_ast_stmt_t_BEGIN, stmt); scc_ast_stmt_t *statement = scc_parse_statement(parser); + scc_sema_stmt(parser, scc_ast_stmt_t_END, stmt); if (!scc_parser_consume_if(parser, SCC_TOK_WHILE)) { SCC_ERROR(scc_parser_got_current_pos(parser), @@ -243,7 +253,6 @@ static scc_ast_stmt_t *parse_do_while_statement(scc_parser_t *parser, SCC_ERROR(scc_parser_got_current_pos(parser), "Expected semicolon after jump statement."); } - scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx); scc_ast_stmt_do_while_init(stmt, expression, statement, pos); return stmt; } @@ -263,6 +272,8 @@ 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); + stmt->base.type = SCC_AST_STMT_FOR; scc_ast_node_t *init = nullptr; scc_ast_expr_t *cond = nullptr; @@ -293,9 +304,10 @@ static scc_ast_stmt_t *parse_for_statement(scc_parser_t *parser, "Expected ')' after like `( expression )` ."); } + scc_sema_stmt(parser, scc_ast_stmt_t_BEGIN, stmt); body = scc_parse_statement(parser); + scc_sema_stmt(parser, scc_ast_stmt_t_END, stmt); - scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx); scc_ast_stmt_for_init(stmt, init, cond, incr, body, pos); return stmt; } diff --git a/libs/parser/src/parse_type.c b/libs/parser/src/parse_type.c index a70aba7..2f9369e 100644 --- a/libs/parser/src/parse_type.c +++ b/libs/parser/src/parse_type.c @@ -575,22 +575,32 @@ static scc_ast_qual_type_t *parse_record_type(scc_parser_t *parser, } const scc_ast_qual_type_t *type = nullptr; if (name == 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_decl_record_init(decl, type_kind, name, nullptr, *pos); - - const scc_ast_qual_type_t *type = - SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx); - _scc_ast_type_record_init(type, canon, type_kind, name, decl, *pos); - return type; + name = ""; } scc_str_append_cstr(&symbol_name, name, scc_strlen(name)); type = scc_parse_got_type(parser, scc_str_as_cstr(&symbol_name)); if (type == nullptr) { + new_type: 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_decl_record_init(decl, type_kind, name, nullptr, *pos); + + scc_ast_node_kind_t decl_kind; + switch (type_kind) { + case SCC_AST_TYPE_ENUM: + decl_kind = SCC_AST_DECL_ENUM; + break; + case SCC_AST_TYPE_STRUCT: + decl_kind = SCC_AST_DECL_STRUCT; + break; + case SCC_AST_TYPE_UNION: + decl_kind = SCC_AST_DECL_UNION; + break; + default: + UNREACHABLE(); + break; + } + _scc_ast_decl_record_init(decl, decl_kind, name, nullptr, *pos); const scc_ast_qual_type_t *qual_type = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx); @@ -1264,36 +1274,21 @@ scc_ast_decl_t *scc_parse_declarator(scc_parser_t *parser, decl_name_tok.loc); } - if (decl_name_tok.type != SCC_TOK_IDENT) { - // TODO(); - // if (decl_type->base.type == SCC_AST_TYPE_STRUCT || - // decl_type->base.type == SCC_AST_TYPE_UNION || - // decl_type->base.type == SCC_AST_TYPE_ENUM) { - // if (scc_ast_canon_type(decl_type)->record.decl == nullptr) { - // decl = SCC_AST_ALLOC_DECL(parser->ast_ctx); - // Assert(decl != nullptr); - // if (decl_type->base.type == SCC_AST_TYPE_STRUCT) { - // scc_ast_decl_struct_init( - // decl, scc_ast_canon_type(decl_type)->record.name, - // nullptr, decl_type->base.loc); - // } else if (decl_type->base.type == SCC_AST_TYPE_UNION) { - // scc_ast_decl_union_init( - // decl, scc_ast_canon_type(decl_type)->record.name, - // nullptr, decl_type->base.loc); - // } else { - // scc_ast_decl_enum_init( - // decl, scc_ast_canon_type(decl_type)->record.name, - // nullptr, decl_type->base.loc); - // } - // } else { - // decl = scc_ast_canon_type(decl_type)->record.decl; - // } - // } else { - // decl = SCC_AST_ALLOC_DECL(parser->ast_ctx); - // scc_ast_decl_unsafe_val_init(decl, type, nullptr, nullptr, - // decl_type->base.loc); - // } - } + // if (decl_name_tok.type != SCC_TOK_IDENT) { + // if (decl_type->base.type == SCC_AST_TYPE_STRUCT || + // decl_type->base.type == SCC_AST_TYPE_UNION || + // decl_type->base.type == SCC_AST_TYPE_ENUM) { + // if (scc_ast_canon_type(decl_type)->record.decl == nullptr) { + // Panic("Expected a struct/union/enum declaration name"); + // } + // decl = scc_ast_canon_type(decl_type)->record.decl; + // } else { + // // TODO(); + // // decl = SCC_AST_ALLOC_DECL(parser->ast_ctx); + // // scc_ast_decl_unsafe_val_init(decl, type, nullptr, nullptr, + // // decl_type->base.loc); + // } + // } return decl; } diff --git a/libs/parser/src/scc_parser.c b/libs/parser/src/scc_parser.c index 17e026e..3ed5ac9 100644 --- a/libs/parser/src/scc_parser.c +++ b/libs/parser/src/scc_parser.c @@ -1,16 +1,16 @@ #include #include -static void dummy_sema_callback(void *context, scc_ast_node_kind_t node_type, - void *node) { +static void dummy_sema_callback(scc_sema_ctx_t *context, + scc_ast_node_kind_t node_type, void *node) { (void)context; (void)node_type; (void)node; return; } -static const scc_ast_qual_type_t *dummy_got_type_callback(void *context, - const char *name) { +static const scc_ast_qual_type_t * +dummy_got_type_callback(scc_sema_ctx_t *context, const char *name) { (void)context; (void)name; return nullptr; @@ -20,7 +20,7 @@ static const scc_ast_qual_type_t *dummy_got_type_callback(void *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 *callbacks) { + scc_ast_ctx_t *ast_ctx, scc_sema_ctx_t *sema_ctx) { Assert(parser != nullptr && tok_ring != nullptr); Assert(ast_ctx != nullptr); parser->ast_ctx = ast_ctx; @@ -28,32 +28,30 @@ void scc_parser_init(scc_parser_t *parser, scc_lexer_tok_ring_t *tok_ring, parser->ring = tok_ring; parser->errcode = 0; parser->translation_unit = nullptr; - if (callbacks) { - ASSIGN_PTR_OR_DEFAULT(parser->sema_callbacks.on_decl, - callbacks->on_decl, dummy_sema_callback); - ASSIGN_PTR_OR_DEFAULT(parser->sema_callbacks.on_stmt, - callbacks->on_stmt, dummy_sema_callback); - ASSIGN_PTR_OR_DEFAULT(parser->sema_callbacks.on_expr, - callbacks->on_expr, dummy_sema_callback); - ASSIGN_PTR_OR_DEFAULT(parser->sema_callbacks.on_type, - callbacks->on_type, dummy_sema_callback); - ASSIGN_PTR_OR_DEFAULT(parser->sema_callbacks.got_type, - callbacks->got_type, dummy_got_type_callback); - parser->sema_callbacks.context = callbacks->context; + if (sema_ctx == nullptr) { + parser->sema_ctx = scc_malloc(sizeof(scc_sema_ctx_t)); + Assert(parser->sema_ctx != nullptr); + parser->sema_ctx->on_decl = dummy_sema_callback; + parser->sema_ctx->on_stmt = dummy_sema_callback; + parser->sema_ctx->on_expr = dummy_sema_callback; + parser->sema_ctx->on_type = dummy_sema_callback; + parser->sema_ctx->got_type = dummy_got_type_callback; + parser->sema_ctx->context = nullptr; + parser->owned_sema = true; } else { - parser->sema_callbacks.on_decl = dummy_sema_callback; - parser->sema_callbacks.on_stmt = dummy_sema_callback; - parser->sema_callbacks.on_expr = dummy_sema_callback; - parser->sema_callbacks.on_type = dummy_sema_callback; - parser->sema_callbacks.got_type = dummy_got_type_callback; - parser->sema_callbacks.context = nullptr; + parser->owned_sema = false; + parser->sema_ctx = sema_ctx; } } void scc_parser_drop(scc_parser_t *parser) { // TODO: 释放 AST 内存 scc_ring_free(*parser->ring); - scc_sema_drop(&parser->sema_callbacks); + if (parser->owned_sema) { + scc_free(parser->sema_ctx); + } else { + scc_sema_drop(parser->sema_ctx); + } } scc_ast_translation_unit_t *scc_parse_translation_unit(scc_parser_t *parser) { diff --git a/libs/parser/src/scc_sema.c b/libs/parser/src/scc_sema.c index c3e6714..a0e63ee 100644 --- a/libs/parser/src/scc_sema.c +++ b/libs/parser/src/scc_sema.c @@ -3,20 +3,20 @@ #include #include -static const scc_ast_qual_type_t *got_type_callback(void *context, +static const scc_ast_qual_type_t *got_type_callback(scc_sema_ctx_t *sema_ctx, const char *name); static void gen_symbol_name(const scc_ast_decl_t *decl, scc_str_t *name) { switch (decl->base.type) { - case SCC_AST_TYPE_ENUM: + case SCC_AST_DECL_ENUM: *name = scc_str_from_cstr("$E_"); scc_str_append_cstr(name, decl->name, scc_strlen(decl->name)); break; - case SCC_AST_TYPE_STRUCT: + case SCC_AST_DECL_STRUCT: *name = scc_str_from_cstr("$S_"); scc_str_append_cstr(name, decl->name, scc_strlen(decl->name)); break; - case SCC_AST_TYPE_UNION: + case SCC_AST_DECL_UNION: *name = scc_str_from_cstr("$U_"); scc_str_append_cstr(name, decl->name, scc_strlen(decl->name)); break; @@ -42,9 +42,9 @@ static void symtab_add_symbol(scc_sema_symtab_t *sema_symtab, } } -static void type_callback(void *context, scc_ast_node_kind_t node_type, - void *node) { - scc_sema_symtab_t *sema_symtab = context; +static void type_callback(scc_sema_ctx_t *sema_ctx, + scc_ast_node_kind_t node_type, void *node) { + scc_sema_symtab_t *sema_symtab = sema_ctx->context; scc_ast_qual_type_t *type = SCC_AST_CAST_TO(scc_ast_qual_type_t, node); if (node_type == SCC_AST_TYPE_STRUCT) { @@ -57,9 +57,9 @@ static void type_callback(void *context, scc_ast_node_kind_t node_type, return; } -static void expr_callback(void *context, scc_ast_node_kind_t node_type, - void *node) { - scc_sema_symtab_t *sema_symtab = context; +static void expr_callback(scc_sema_ctx_t *sema_ctx, + scc_ast_node_kind_t node_type, void *node) { + scc_sema_symtab_t *sema_symtab = sema_ctx->context; if (node_type == SCC_AST_UNKNOWN || node == nullptr) { return; @@ -83,26 +83,96 @@ static void expr_callback(void *context, scc_ast_node_kind_t node_type, return; } -static void stmt_callback(void *context, scc_ast_node_kind_t node_type, - void *node) { - scc_sema_symtab_t *sema_symtab = context; +static void stmt_callback(scc_sema_ctx_t *sema_ctx, + scc_ast_node_kind_t node_type, void *node) { + scc_sema_symtab_t *sema_symtab = sema_ctx->context; if (node_type == scc_ast_stmt_t_BEGIN) { - scc_sema_symtab_enter_scope(sema_symtab); + if (node == nullptr) { + scc_sema_symtab_enter_scope(sema_symtab); + return; + } + switch (((scc_ast_stmt_t *)node)->base.type) { + case SCC_AST_STMT_WHILE: + case SCC_AST_STMT_DO_WHILE: + case SCC_AST_STMT_FOR: + scc_vec_push(sema_ctx->break_stack, (scc_ast_stmt_t *)node); + scc_vec_push(sema_ctx->continue_stack, (scc_ast_stmt_t *)node); + break; + case SCC_AST_STMT_SWITCH: + scc_vec_push(sema_ctx->break_stack, (scc_ast_stmt_t *)node); + break; + default: + Panic("Unhandled statement type"); + break; + } return; } else if (node_type == scc_ast_stmt_t_END) { - scc_sema_symtab_leave_scope(sema_symtab); + if (node == nullptr) { + scc_sema_symtab_leave_scope(sema_symtab); + return; + } + switch (((scc_ast_stmt_t *)node)->base.type) { + case SCC_AST_STMT_WHILE: + case SCC_AST_STMT_DO_WHILE: + case SCC_AST_STMT_FOR: + scc_vec_pop(sema_ctx->break_stack); + scc_vec_pop(sema_ctx->continue_stack); + break; + case SCC_AST_STMT_SWITCH: + scc_vec_pop(sema_ctx->break_stack); + break; + default: + Panic("Unhandled statement type"); + break; + } return; } if (node_type == SCC_AST_UNKNOWN || node == nullptr) { return; } + scc_ast_stmt_t *stmt = SCC_AST_CAST_TO(scc_ast_stmt_t, node); + switch (stmt->base.type) { + case SCC_AST_STMT_BREAK: + if (scc_vec_size(sema_ctx->break_stack) == 0) + SCC_ERROR(stmt->base.loc, "break not in loop/switch"); + else + stmt->jump._target = scc_vec_at( + sema_ctx->break_stack, scc_vec_size(sema_ctx->break_stack) - 1); + break; + case SCC_AST_STMT_CONTINUE: + if (scc_vec_size(sema_ctx->continue_stack) == 0) + SCC_ERROR(stmt->base.loc, "continue not in loop"); + else + stmt->jump._target = + scc_vec_at(sema_ctx->continue_stack, + scc_vec_size(sema_ctx->continue_stack) - 1); + case SCC_AST_STMT_GOTO: + scc_ast_node_t *target_node = + scc_sema_symtab_lookup_symbol(sema_symtab, stmt->goto_stmt.label); + if (target_node == nullptr) { + SCC_ERROR(stmt->base.loc, ""); + break; + } + if (!SCC_AST_IS_A(scc_ast_stmt_t, target_node)) { + SCC_ERROR(stmt->base.loc, ""); + break; + } + stmt->goto_stmt._target = SCC_AST_CAST_TO(scc_ast_stmt_t, target_node); + break; + case SCC_AST_STMT_LABEL: + scc_sema_symtab_add_symbol(sema_symtab, stmt->label_stmt.label, + &stmt->base); + break; + default: + break; + } return; } -static void decl_callback(void *context, scc_ast_node_kind_t node_type, - void *node) { - scc_sema_symtab_t *sema_symtab = context; +static void decl_callback(scc_sema_ctx_t *sema_ctx, + scc_ast_node_kind_t node_type, void *node) { + scc_sema_symtab_t *sema_symtab = sema_ctx->context; // Function declaration scope if (node_type == scc_ast_decl_t_BEGIN) { @@ -149,9 +219,9 @@ static void decl_callback(void *context, scc_ast_node_kind_t node_type, return; } -static const scc_ast_qual_type_t *got_type_callback(void *context, +static const scc_ast_qual_type_t *got_type_callback(scc_sema_ctx_t *sema_ctx, const char *name) { - scc_sema_symtab_t *sema_symtab = context; + scc_sema_symtab_t *sema_symtab = sema_ctx->context; scc_ast_node_t *node = scc_sema_symtab_lookup_symbol(sema_symtab, name); if (SCC_AST_IS_A(scc_ast_qual_type_t, node)) { return (scc_ast_qual_type_t *)node; @@ -175,6 +245,9 @@ void scc_sema_init(scc_sema_ctx_t *sema_ctx, scc_ast_ctx_t *ast_ctx) { scc_sema_symtab_init(sema_symtab); + 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); @@ -207,6 +280,11 @@ void scc_sema_init(scc_sema_ctx_t *sema_ctx, scc_ast_ctx_t *ast_ctx) { } void scc_sema_drop(scc_sema_ctx_t *sema_ctx) { + Assert(scc_vec_size(sema_ctx->break_stack) == 0 && + scc_vec_size(sema_ctx->continue_stack) == 0); + 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); diff --git a/runtime/scc_utils/cbuild.toml b/runtime/scc_utils/cbuild.toml index 51a9988..c0cd156 100644 --- a/runtime/scc_utils/cbuild.toml +++ b/runtime/scc_utils/cbuild.toml @@ -1,5 +1,8 @@ [package] -name = "scc_utils" +name = "scc_utils" version = "0.1.0" -dependencies = [{ name = "core", path = "../scc_core" }] +dependencies = [ + { name = "core", path = "../scc_core" }, + { name = "ap", path = "../ap" }, +]