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

refactor(ast): 将AST类型系统重构为规范类型系统

Browse Source 
- 将scc_ast_type_t替换为scc_ast_qual_type_t，引入规范类型概念
- 添加scc_ast_canonical_type_t联合体用于表示规范类型
- 修改头文件结构，移除大量内联初始化函数，改为使用AST上下文分配器
- 添加SCC_AST_ALLOC宏用于统一节点分配管理
- 更新builtin类型枚举定义，添加类型计数常量

feat(ast): 引入AST上下文管理器

- 创建scc_ast_ctx_t结构体用于管理AST节点生命周期
- 实现类型池化机制，支持内置类型的统一管理
- 添加canonical类型获取和分配接口

refactor(abi): 适配新的AST类型系统

- 更新头文件包含，从<scc_ir.h>改为<scc_hir.h>
- 适配函数参数类型，使用qual_type替代原始type
- 使用scc_ast_canon_type()函数获取规范类型进行处理

Co-authored-by: Copilot <copilot@github.com>
This commit is contained in:
zzy
2026-04-27 20:40:03 +08:00
parent d7ac5fd30b
commit f6bc40ae4a
20 changed files with 1302 additions and 1045 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
libs/parser/include/scc_parse_type.h Normal file
View File

@@ -0,0 +1,108 @@
#ifndef __SCC_PARSE_TYPE_H__
#define __SCC_PARSE_TYPE_H__
#include <scc_ast.h>
#include <scc_ast_utils.h>
static inline void scc_ast_type_pointer_init(scc_ast_qual_type_t *type,
scc_ast_canon_type_t *canon,
scc_ast_qual_type_t *pointee,
scc_pos_t loc) {
Assert(type != nullptr && pointee != nullptr);
type->base.loc = loc;
type->base.type = SCC_AST_TYPE_POINTER;
type->quals = (scc_ast_decl_specifier_t){0};
type->type = canon;
canon->pointer.pointee = pointee;
}
// size can be nullptr
static inline void scc_ast_type_array_init(scc_ast_qual_type_t *type,
scc_ast_canon_type_t *canon,
scc_ast_qual_type_t *element,
scc_ast_expr_t *size,
scc_pos_t loc) {
Assert(type != nullptr && element != nullptr);
type->base.loc = loc;
type->base.type = SCC_AST_TYPE_ARRAY;
type->quals = (scc_ast_decl_specifier_t){0};
type->type = canon;
canon->array.element = element;
canon->array.size = size;
}
// return_type and params can be nullptr
static inline void scc_ast_type_function_init(scc_ast_qual_type_t *type,
scc_ast_canon_type_t *canon,
scc_ast_qual_type_t *return_type,
scc_ast_decl_vec_t *params,
scc_pos_t loc) {
Assert(type != nullptr);
type->base.loc = loc;
type->base.type = SCC_AST_TYPE_FUNCTION;
type->quals = (scc_ast_decl_specifier_t){0};
type->type = canon;
canon->function.return_type = return_type;
if (params == nullptr) {
scc_vec_init(canon->function.params);
} else {
canon->function.params = *params;
scc_vec_init(*params);
}
}
static inline void _scc_ast_type_record_init(scc_ast_qual_type_t *type,
scc_ast_canon_type_t *canon,
scc_ast_node_kind_t type_kind,
const char *name,
scc_ast_decl_t *decl,
scc_pos_t loc) {
Assert(type != nullptr);
type->base.loc = loc;
type->base.type = type_kind;
type->quals = (scc_ast_decl_specifier_t){0};
type->type = canon;
canon->record.name = name;
canon->record.decl = decl;
}
// name and decl can be nullptr
static inline void scc_ast_type_struct_init(scc_ast_qual_type_t *type,
scc_ast_canon_type_t *canon,
const char *name,
scc_ast_decl_t *decl,
scc_pos_t loc) {
_scc_ast_type_record_init(type, canon, SCC_AST_TYPE_STRUCT, name, decl,
loc);
}
// name and decl can be nullptr
static inline void
scc_ast_type_union_init(scc_ast_qual_type_t *type, scc_ast_canon_type_t *canon,
const char *name, scc_ast_decl_t *decl, scc_pos_t loc) {
_scc_ast_type_record_init(type, canon, SCC_AST_TYPE_UNION, name, decl, loc);
}
// name and decl can be nullptr
static inline void scc_ast_type_enum_init(scc_ast_qual_type_t *type,
scc_ast_canon_type_t *canon,
const char *name,
scc_ast_decl_t *decl, scc_pos_t loc) {
_scc_ast_type_record_init(type, canon, SCC_AST_TYPE_ENUM, name, decl, loc);
}
static inline void scc_ast_type_typedef_init(scc_ast_qual_type_t *type,
scc_ast_canon_type_t *canon,
const char *name,
scc_ast_decl_t *target,
scc_pos_t loc) {
Assert(type != nullptr && target != nullptr);
type->base.loc = loc;
type->base.type = SCC_AST_TYPE_TYPEDEF;
type->quals = (scc_ast_decl_specifier_t){0};
type->type = canon;
canon->typedef_type.name = name;
canon->typedef_type.decl = target;
}
#endif /* __SCC_PARSE_TYPE_H__ */

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

@@ -14,12 +14,13 @@ typedef struct scc_parser {
scc_lexer_tok_ring_t *ring;
usize checkpoint;
scc_sema_callbacks_t sema_callbacks;
scc_ast_ctx_t *ast_ctx;
scc_sema_ctx_t sema_callbacks;
scc_ast_translation_unit_t *translation_unit;
int errcode;
} scc_parser_t;
// static inline scc_ast_type_t *scc_parser_
// static inline scc_ast_qual_type_t *scc_parser_
/**
* @brief 初始化解析器
@@ -28,7 +29,7 @@ typedef struct scc_parser {
* @param callbacks 语义分析回调(可为 nullptr)
*/
void scc_parser_init(scc_parser_t *parser, scc_lexer_tok_ring_t *tok_ring,
scc_sema_callbacks_t *callbacks);
scc_ast_ctx_t *ast_ctx, scc_sema_ctx_t *callbacks);
/**
* @brief 销毁解析器
@@ -74,9 +75,9 @@ scc_ast_expr_t *scc_parse_expression(scc_parser_t *parser);
* @return 类型 AST 节点
*/
scc_ast_decl_t *scc_parse_declarator(scc_parser_t *parser,
scc_ast_type_t *type);
scc_ast_type_t *scc_parse_declaration_specifiers(scc_parser_t *parser);
scc_ast_type_t *scc_parse_type_name(scc_parser_t *parser);
scc_ast_qual_type_t *type);
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_parse_decl_sema(scc_parser_t *parser,
scc_ast_decl_t *decl) {
@@ -100,14 +101,14 @@ static inline void scc_parse_stmt_sema(scc_parser_t *parser,
}
static inline void scc_parse_type_sema(scc_parser_t *parser,
scc_ast_type_t *type) {
scc_ast_qual_type_t *type) {
parser->sema_callbacks.on_type(parser->sema_callbacks.context,
type ? type->base.type : SCC_AST_UNKNOWN,
type);
}
static inline scc_ast_type_t *scc_parse_got_type(scc_parser_t *parser,
const char *name) {
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);
}

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

@@ -9,21 +9,23 @@
typedef void (*scc_sema_callback_t)(void *context,
scc_ast_node_kind_t node_type, void *node);
typedef scc_ast_type_t *(*scc_sema_got_type_t)(void *context, const char *name);
typedef const scc_ast_qual_type_t *(*scc_sema_got_type_t)(void *context,
const char *name);
/**
* @brief 语义分析回调集合
*/
typedef struct scc_sema_callbacks {
typedef 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;
void *context;
} scc_sema_callbacks_t;
} scc_sema_ctx_t;
void scc_sema_init(scc_sema_callbacks_t *callbacks);
void scc_sema_drop(scc_sema_callbacks_t *callbacks);
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);
#endif /* __SCC_SEMA_H__ */

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

@@ -152,6 +152,7 @@ A.2.4 External definitions
*/
#include <parser_utils.h>
#include <scc_ast_utils.h>
#include <scc_parser.h>
scc_ast_expr_t *scc_parse_initializer(scc_parser_t *parser,
@@ -186,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_malloc(sizeof(scc_ast_expr_t));
init = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(init != nullptr);
scc_ast_expr_vec_t lhs_exprs;
scc_vec_init(lhs_exprs);
@@ -202,7 +203,7 @@ 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_malloc(sizeof(scc_ast_expr_t));
lhs = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(lhs != nullptr);
scc_ast_expr_member_init(lhs, ptr, scc_str_as_cstr(&tok.lexeme),
tok.loc);
@@ -230,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_malloc(sizeof(scc_ast_expr_t));
lhs = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(lhs != nullptr);
scc_ast_expr_array_subscript_init(lhs, ptr, idx, tok_ptr->loc);
if (!scc_parser_consume_if(parser, SCC_TOK_ASSIGN)) {
@@ -266,7 +267,7 @@ scc_ast_decl_t *scc_parse_declaration(scc_parser_t *parser) {
scc_ast_decl_vec_t decl_list_vec;
scc_vec_init(decl_list_vec);
scc_ast_type_t *type = scc_parse_declaration_specifiers(parser);
scc_ast_qual_type_t *type = scc_parse_declaration_specifiers(parser);
if (type == nullptr) {
return nullptr;
}
@@ -284,16 +285,17 @@ CONTINUE:
if (tok_ptr->type == SCC_TOK_ASSIGN) {
scc_parser_next_consume(parser, nullptr);
// TODO maybe memory leak
scc_ast_expr_t *lvalue = scc_malloc(sizeof(scc_ast_expr_t));
scc_ast_expr_t *lvalue = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
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) {
scc_parse_decl_sema(parser, decl);
parser->sema_callbacks.on_decl(parser->sema_callbacks.context,
scc_ast_decl_t_BEGIN, nullptr);
scc_vec_foreach(decl->func.type->function.params, i) {
// FIXME hack struct
scc_vec_foreach(decl->func.type->type->function.params, i) {
scc_ast_decl_t *param =
scc_vec_at(decl->func.type->function.params, i);
scc_vec_at(decl->func.type->type->function.params, i);
// Add params to decl
scc_parse_decl_sema(parser, param);
}
@@ -342,7 +344,7 @@ CONTINUE:
} else if (tok_ptr->type == SCC_TOK_COMMA) {
scc_parser_next_consume(parser, nullptr);
if (decl_list == nullptr) {
decl_list = scc_malloc(sizeof(scc_ast_decl_t));
decl_list = SCC_AST_ALLOC_DECL(parser->ast_ctx);
Assert(decl_list != nullptr);
scc_vec_push(decl_list_vec, decl);
} else {

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

@@ -106,6 +106,7 @@ A.2.1 Expressions
*/
#include <parser_utils.h>
#include <scc_ast_utils.h>
#include <scc_parser.h>
/**
@@ -370,7 +371,7 @@ static scc_ast_expr_t *parse_expression_with_precedence(scc_parser_t *parser,
return nullptr;
}
scc_ast_expr_t *expr = scc_malloc(sizeof(scc_ast_expr_t));
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(expr != nullptr);
// FIXME pos
scc_ast_expr_binary_init(expr, op, left, right, left->base.loc);
@@ -409,7 +410,7 @@ scc_ast_expr_t *scc_parse_assignment_expression(scc_parser_t *parser) {
return nullptr;
}
scc_ast_expr_t *expr = scc_malloc(sizeof(scc_ast_expr_t));
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(expr != nullptr);
scc_ast_expr_binary_init(expr, op, left, right, pos);
left = expr;
@@ -455,7 +456,7 @@ static scc_ast_expr_t *parse_conditional_expression(scc_parser_t *parser) {
return nullptr;
}
scc_ast_expr_t *cond = scc_malloc(sizeof(scc_ast_expr_t));
scc_ast_expr_t *cond = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(cond != nullptr);
scc_ast_expr_cond_init(cond, cond_expr, then_expr, else_expr, pos);
cond_expr = cond;
@@ -466,7 +467,7 @@ static scc_ast_expr_t *parse_conditional_expression(scc_parser_t *parser) {
// 类型转换表达式 (type-name) cast-expression
static scc_ast_expr_t *parse_cast_expression(scc_parser_t *parser) {
const scc_lexer_tok_t *tok_ptr = scc_parser_peek(parser);
scc_ast_type_t *type = nullptr;
scc_ast_qual_type_t *type = nullptr;
if (tok_ptr && tok_ptr->type == SCC_TOK_L_PAREN) {
// 尝试解析类型名
scc_parser_store(parser);
@@ -480,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_malloc(sizeof(scc_ast_expr_t));
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
// 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_malloc(sizeof(scc_ast_expr_t));
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(expr != nullptr);
// FIXME pos
scc_ast_expr_cast_init(expr, type, operand, type->base.loc);
@@ -558,7 +559,7 @@ static scc_ast_expr_t *parse_unary_expression(scc_parser_t *parser) {
return nullptr;
}
scc_ast_expr_t *expr = scc_malloc(sizeof(scc_ast_expr_t));
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(expr != nullptr);
scc_ast_expr_unary_init(expr, op, operand, pos);
return expr;
@@ -587,12 +588,12 @@ static scc_ast_expr_t *parse_sizeof_expression(scc_parser_t *parser) {
return nullptr;
}
scc_ast_expr_t *expr = scc_malloc(sizeof(scc_ast_expr_t));
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
if (next->type == SCC_TOK_L_PAREN) {
scc_parser_store(parser);
scc_parser_next(parser);
scc_ast_type_t *type_name = scc_parse_type_name(parser);
scc_ast_qual_type_t *type_name = scc_parse_type_name(parser);
if (type_name == nullptr) {
scc_parser_restore(parser);
goto next;
@@ -633,7 +634,7 @@ static scc_ast_expr_t *parse_postfix_expression(scc_parser_t *parser) {
scc_parser_store(parser);
scc_parser_next(parser);
scc_ast_type_t *type = scc_parse_type_name(parser);
scc_ast_qual_type_t *type = scc_parse_type_name(parser);
if (!type) {
scc_parser_restore(parser);
return nullptr;
@@ -642,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_malloc(sizeof(scc_ast_expr_t));
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
scc_ast_expr_lvalue_init(expr, type, pos);
left = scc_parse_initializer(parser, expr);
return left;
@@ -671,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_malloc(sizeof(scc_ast_expr_t));
scc_ast_expr_t *subscript = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(subscript != nullptr);
scc_ast_expr_array_subscript_init(subscript, left, index, pos);
left = subscript;
@@ -708,7 +709,7 @@ static scc_ast_expr_t *parse_postfix_expression(scc_parser_t *parser) {
return nullptr;
}
}
scc_ast_expr_t *call = scc_malloc(sizeof(scc_ast_expr_t));
scc_ast_expr_t *call = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(call != nullptr);
scc_ast_expr_call_init(call, left, &args, pos);
left = call;
@@ -730,7 +731,7 @@ static scc_ast_expr_t *parse_postfix_expression(scc_parser_t *parser) {
}
const char *name = scc_str_as_cstr(&ident_tok.lexeme);
scc_ast_expr_t *member = scc_malloc(sizeof(scc_ast_expr_t));
scc_ast_expr_t *member = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(member != nullptr);
if (op_tok.type == SCC_TOK_DOT) {
scc_ast_expr_member_init(member, left, name, ident_tok.loc);
@@ -749,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_malloc(sizeof(scc_ast_expr_t));
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(expr != nullptr);
scc_ast_expr_unary_init(expr, op, left, op_tok.loc);
scc_lexer_tok_drop(&op_tok);
@@ -784,7 +785,7 @@ 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_malloc(sizeof(scc_ast_expr_t));
expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(expr != nullptr);
scc_ast_expr_identifier_init(expr, scc_str_as_cstr(&tok.lexeme),
tok.loc);
@@ -793,7 +794,7 @@ static scc_ast_expr_t *parse_primary_expression(scc_parser_t *parser) {
case SCC_TOK_INT_LITERAL: {
if (!scc_parser_next_consume(parser, &tok))
return nullptr;
expr = scc_malloc(sizeof(scc_ast_expr_t));
expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(expr != nullptr);
scc_ast_expr_literal_int_init(expr, scc_str_as_cstr(&tok.lexeme), false,
tok.loc);
@@ -802,7 +803,7 @@ static scc_ast_expr_t *parse_primary_expression(scc_parser_t *parser) {
case SCC_TOK_FLOAT_LITERAL: {
if (!scc_parser_next_consume(parser, &tok))
return nullptr;
expr = scc_malloc(sizeof(scc_ast_expr_t));
expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(expr != nullptr);
scc_ast_expr_literal_float_init(expr, scc_str_as_cstr(&tok.lexeme),
false, tok.loc);
@@ -811,7 +812,7 @@ static scc_ast_expr_t *parse_primary_expression(scc_parser_t *parser) {
case SCC_TOK_CHAR_LITERAL: {
if (!scc_parser_next_consume(parser, &tok))
return nullptr;
expr = scc_malloc(sizeof(scc_ast_expr_t));
expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(expr != nullptr);
scc_ast_expr_literal_char_init(expr, scc_str_as_cstr(&tok.lexeme),
false, tok.loc);
@@ -834,7 +835,7 @@ static scc_ast_expr_t *parse_primary_expression(scc_parser_t *parser) {
scc_str_append(&string, &tmp);
}
expr = scc_malloc(sizeof(scc_ast_expr_t));
expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(expr != nullptr);
// FIXME loc
scc_ast_expr_literal_string_init(expr, scc_str_as_cstr(&string), true,
@@ -879,7 +880,7 @@ scc_ast_expr_t *scc_parse_expression(scc_parser_t *parser) {
parser_sync(parser);
return nullptr;
}
scc_ast_expr_t *expr = scc_malloc(sizeof(scc_ast_expr_t));
scc_ast_expr_t *expr = SCC_AST_ALLOC_EXPR(parser->ast_ctx);
Assert(expr != nullptr);
scc_ast_expr_binary_init(expr, SCC_AST_OP_COMMA, left, right, pos);
left = expr;

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

@@ -48,16 +48,9 @@ A.2.3 Statements
*/
#include <parser_utils.h>
#include <scc_ast_utils.h>
#include <scc_parser.h>
static inline scc_ast_stmt_t *ast_stmt_alloc() {
scc_ast_stmt_t *stmt = (scc_ast_stmt_t *)scc_malloc(sizeof(scc_ast_stmt_t));
if (stmt == nullptr) {
LOG_FATAL("Out of memory");
}
return stmt;
}
static inline scc_ast_expr_t *ast_parse_paren_expression(scc_parser_t *parser) {
if (!scc_parser_consume_if(parser, SCC_TOK_L_PAREN)) {
SCC_ERROR(scc_parser_got_current_pos(parser),
@@ -90,7 +83,7 @@ static scc_ast_stmt_t *parse_label_statement(scc_parser_t *parser,
Panic("expect stmt");
}
scc_ast_stmt_t *stmt = ast_stmt_alloc();
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
Assert(stmt != nullptr);
scc_ast_stmt_label_init(stmt, scc_str_as_cstr(&tok.lexeme), statement, pos);
return stmt;
@@ -121,7 +114,7 @@ static scc_ast_stmt_t *parse_case_statement(scc_parser_t *parser,
Panic("expect stmt");
}
scc_ast_stmt_t *stmt = ast_stmt_alloc();
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_case_init(stmt, expr, statement, pos);
return stmt;
}
@@ -143,7 +136,7 @@ static scc_ast_stmt_t *parse_default_statement(scc_parser_t *parser,
Panic("expect stmt");
}
scc_ast_stmt_t *stmt = ast_stmt_alloc();
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_default_init(stmt, statement, pos);
return stmt;
}
@@ -177,7 +170,7 @@ static scc_ast_stmt_t *parse_compound_statement(scc_parser_t *parser,
parser->sema_callbacks.on_stmt(parser->sema_callbacks.context,
scc_ast_stmt_t_END, nullptr);
scc_ast_stmt_t *stmt = ast_stmt_alloc();
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_compound_init(stmt, &block_items, pos);
return stmt;
}
@@ -197,7 +190,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 = ast_stmt_alloc();
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_if_init(stmt, expression, statement, opt_else, pos);
return stmt;
}
@@ -211,7 +204,7 @@ static scc_ast_stmt_t *parse_switch_statement(scc_parser_t *parser,
scc_ast_expr_t *expression = ast_parse_paren_expression(parser);
scc_ast_stmt_t *statement = scc_parse_statement(parser);
scc_ast_stmt_t *stmt = ast_stmt_alloc();
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_switch_init(stmt, expression, statement, pos);
return stmt;
}
@@ -225,7 +218,7 @@ static scc_ast_stmt_t *parse_while_statement(scc_parser_t *parser,
scc_ast_expr_t *expression = ast_parse_paren_expression(parser);
scc_ast_stmt_t *statement = scc_parse_statement(parser);
scc_ast_stmt_t *stmt = ast_stmt_alloc();
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_while_init(stmt, expression, statement, pos);
return stmt;
}
@@ -242,7 +235,6 @@ static scc_ast_stmt_t *parse_do_while_statement(scc_parser_t *parser,
SCC_ERROR(scc_parser_got_current_pos(parser),
"Expected 'while' after do.");
// TODO 使用更好的错误处理，未来应当采用更好的内存管理器
scc_free(statement);
return nullptr;
}
scc_ast_expr_t *expression = ast_parse_paren_expression(parser);
@@ -251,7 +243,7 @@ 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 = ast_stmt_alloc();
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_do_while_init(stmt, expression, statement, pos);
return stmt;
}
@@ -303,14 +295,14 @@ static scc_ast_stmt_t *parse_for_statement(scc_parser_t *parser,
body = scc_parse_statement(parser);
scc_ast_stmt_t *stmt = ast_stmt_alloc();
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;
}
static scc_ast_stmt_t *parse_jump_statement(scc_parser_t *parser,
scc_pos_t pos) {
scc_ast_stmt_t *stmt = ast_stmt_alloc();
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
if (scc_parser_consume_if(parser, SCC_TOK_GOTO)) {
scc_lexer_tok_t tok = {0};
@@ -341,7 +333,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 = ast_stmt_alloc();
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_expr_init(stmt, nullptr, pos);
return stmt;
}
@@ -351,7 +343,7 @@ static scc_ast_stmt_t *parse_expression_statement(scc_parser_t *parser,
return nullptr;
}
scc_ast_stmt_t *stmt = ast_stmt_alloc();
scc_ast_stmt_t *stmt = SCC_AST_ALLOC_STMT(parser->ast_ctx);
scc_ast_stmt_expr_init(stmt, expr, pos);
if (!scc_parser_consume_if(parser, SCC_TOK_SEMICOLON)) {

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

@@ -157,31 +157,24 @@ EXAMPLE The constructions
*/
#include <parser_utils.h>
#include <scc_parse_type.h>
#include <scc_parser.h>
static scc_ast_type_t *parse_declarator(scc_parser_t *parser,
scc_ast_type_t *base,
scc_ast_type_t **delay_pointee_ptr,
scc_lexer_tok_t *tok_ident);
static scc_ast_type_t *
parse_direct_declarator(scc_parser_t *parser, scc_ast_type_t *base,
scc_ast_type_t **delay_pointee_ptr,
static scc_ast_qual_type_t *
parse_declarator(scc_parser_t *parser, scc_ast_qual_type_t *base,
scc_ast_qual_type_t **delay_pointee_ptr,
scc_lexer_tok_t *tok_ident);
static scc_ast_qual_type_t *
parse_direct_declarator(scc_parser_t *parser, scc_ast_qual_type_t *base,
scc_ast_qual_type_t **delay_pointee_ptr,
scc_lexer_tok_t *tok_ident);
static scc_ast_type_t *
parse_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
scc_ast_type_t **delay_pointee_ptr);
static scc_ast_type_t *
parse_direct_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
scc_ast_type_t **delay_pointee_ptr);
static inline scc_ast_type_t *ast_type_alloc() {
scc_ast_type_t *ast_type = scc_malloc(sizeof(scc_ast_type_t));
ast_type->base.type = SCC_AST_UNKNOWN;
if (ast_type == nullptr) {
LOG_FATAL("Out of memory");
}
return ast_type;
}
static scc_ast_qual_type_t *
parse_abstract_declarator(scc_parser_t *parser, scc_ast_qual_type_t *base,
scc_ast_qual_type_t **delay_pointee_ptr);
static scc_ast_qual_type_t *
parse_direct_abstract_declarator(scc_parser_t *parser,
scc_ast_qual_type_t *base,
scc_ast_qual_type_t **delay_pointee_ptr);
/**
* @brief 判断 token 是否为声明说明符的开始
@@ -306,6 +299,7 @@ cbool scc_parse_is_storage_class_start(scc_parser_t *parser) {
goto duplicate_error; \
expr = true; \
} while (0)
static scc_ast_decl_specifier_t
parse_type_qualifier_list(scc_parser_t *parser,
scc_ast_decl_specifier_t quals) {
@@ -407,7 +401,7 @@ typedef struct {
cbool is_unsigned; // 显式 unsigned
// 以下用于 struct/union/enum/typedef-name
scc_ast_type_t *user_type; // 如果是用户定义类型，直接存储解析结果
scc_ast_qual_type_t *user_type; // 如果是用户定义类型，直接存储解析结果
} type_spec_info_t;
static cbool check_type_combinations(scc_parser_t *parser,
@@ -467,8 +461,9 @@ static cbool check_type_combinations(scc_parser_t *parser,
}
return true;
}
static scc_ast_type_t *build_type_from_info(type_spec_info_t *info,
scc_pos_t pos) {
static scc_ast_qual_type_t *build_type_from_info(scc_parser_t *parser,
type_spec_info_t *info,
scc_pos_t pos) {
// 如果有用户定义类型，直接返回（注意可能需要复制或共享）
if (info->user_type) {
return info->user_type; // 假设 parse_struct_union_enum 已分配好节点
@@ -531,13 +526,86 @@ static scc_ast_type_t *build_type_from_info(type_spec_info_t *info,
}
}
scc_ast_type_t *type = ast_type_alloc();
scc_ast_type_builtin_init(type, builtin, pos);
// 注意：限定符（const, volatile）不应在此处处理，应由上层函数负责
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);
return type;
}
static scc_ast_type_t *parse_record_type(scc_parser_t *parser,
scc_ast_node_kind_t type_kind) {
static scc_ast_qual_type_t *parse_record_type(scc_parser_t *parser,
scc_pos_t *pos,
scc_ast_node_kind_t type_kind) {
scc_lexer_tok_t tok;
// skip 'struct' or 'union' or 'enum'
scc_parser_next_consume(parser, &tok);
*pos = tok.loc;
scc_lexer_tok_drop(&tok);
const scc_lexer_tok_t *tok_ptr = scc_parser_peek(parser);
if (tok_ptr == nullptr) {
SCC_ERROR(scc_parser_got_current_pos(parser), "Unexpected EOF");
return nullptr;
}
const char *name = nullptr;
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);
} else if (tok_ptr->type != SCC_TOK_L_BRACE) {
SCC_ERROR(scc_parser_got_current_pos(parser),
"Expected name in struct/union/enum specifier");
return nullptr;
}
scc_str_t symbol_name;
switch (type_kind) {
case SCC_AST_TYPE_ENUM:
symbol_name = scc_str_from_cstr("$E_");
break;
case SCC_AST_TYPE_STRUCT:
symbol_name = scc_str_from_cstr("$S_");
break;
case SCC_AST_TYPE_UNION:
symbol_name = scc_str_from_cstr("$U_");
break;
default:
UNREACHABLE();
break;
}
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;
}
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) {
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 *qual_type =
SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
_scc_ast_type_record_init(qual_type, canon, type_kind, name, decl,
*pos);
scc_parse_type_sema(parser, qual_type);
type = scc_parse_got_type(parser, scc_str_as_cstr(&symbol_name));
Assert(type == qual_type);
}
Assert(type != nullptr);
return type;
}
static scc_ast_qual_type_t *
parse_struct_union_type(scc_parser_t *parser, scc_ast_node_kind_t type_kind) {
/*
(6.7.2.1)
struct-or-union-specifier:
@@ -568,27 +636,15 @@ static scc_ast_type_t *parse_record_type(scc_parser_t *parser,
declarator(opt) : constant-expression
*/
// FIXME check struct/union
scc_lexer_tok_t tok;
scc_parser_next_consume(parser, &tok);
scc_pos_t pos = tok.loc;
scc_lexer_tok_drop(&tok);
scc_lexer_tok_t tok = {0};
scc_pos_t pos = scc_pos_create();
scc_ast_qual_type_t *type = parse_record_type(parser, &pos, type_kind);
Assert(type != nullptr);
scc_ast_decl_t *decl = type->type->record.decl;
Assert(decl != nullptr);
const scc_lexer_tok_t *tok_ptr = scc_parser_peek(parser);
if (tok_ptr == nullptr) {
SCC_ERROR(scc_parser_got_current_pos(parser), "Unexpected EOF");
return nullptr;
}
const char *name = nullptr;
scc_ast_decl_t *decl = nullptr;
scc_ast_decl_vec_t member;
scc_vec_init(member);
if (tok_ptr->type == SCC_TOK_IDENT) {
scc_parser_next_consume(parser, &tok);
name = scc_str_as_cstr(&tok.lexeme);
tok_ptr = scc_parser_peek(parser);
}
if (tok_ptr && tok_ptr->type == SCC_TOK_L_BRACE) {
scc_parser_next_consume(parser, nullptr);
while (1) {
@@ -599,11 +655,13 @@ static scc_ast_type_t *parse_record_type(scc_parser_t *parser,
break;
}
scc_ast_type_t *type = scc_parse_declaration_specifiers(parser);
if (type != nullptr) {
decl = scc_parse_declarator(parser, type);
if (decl != nullptr) {
scc_vec_push(member, decl);
scc_ast_qual_type_t *new_type =
scc_parse_declaration_specifiers(parser);
if (new_type != nullptr) {
scc_ast_decl_t *new_decl =
scc_parse_declarator(parser, new_type);
if (new_decl != nullptr) {
scc_vec_push(decl->record.fields, new_decl);
continue;
}
}
@@ -621,30 +679,12 @@ static scc_ast_type_t *parse_record_type(scc_parser_t *parser,
break;
}
}
decl = scc_malloc(sizeof(scc_ast_decl_t));
Assert(decl != nullptr);
if (type_kind == SCC_AST_TYPE_STRUCT) {
scc_ast_decl_struct_init(decl, name, &member, pos);
} else {
scc_ast_decl_union_init(decl, name, &member, pos);
}
scc_parse_decl_sema(parser, decl);
} else {
if (name == nullptr) {
SCC_ERROR(scc_parser_got_current_pos(parser),
"Expected name in struct/union specifier");
// FIXME memory leak
return nullptr;
}
}
scc_ast_type_t *type = ast_type_alloc();
_scc_ast_type_record_init(type, type_kind, name, decl, pos);
return type;
}
static scc_ast_type_t *parse_enum_type(scc_parser_t *parser) {
static scc_ast_qual_type_t *parse_enum_type(scc_parser_t *parser) {
/*
(6.7.2.2)
enum-specifier:
@@ -661,31 +701,15 @@ static scc_ast_type_t *parse_enum_type(scc_parser_t *parser) {
enumeration-constant = constant-expression
*/
scc_lexer_tok_t tok;
scc_parser_next_consume(parser, &tok);
scc_pos_t pos = tok.loc;
if (tok.type != SCC_TOK_ENUM) {
SCC_ERROR(scc_parser_got_current_pos(parser), "Expected 'enum'");
return nullptr;
}
scc_lexer_tok_drop(&tok);
scc_pos_t pos = scc_pos_create();
scc_ast_qual_type_t *type =
parse_record_type(parser, &pos, SCC_AST_TYPE_ENUM);
Assert(type != nullptr);
scc_ast_decl_t *decl = type->type->record.decl;
Assert(decl != nullptr);
const scc_lexer_tok_t *tok_ptr = scc_parser_peek(parser);
if (tok_ptr == nullptr) {
SCC_ERROR(scc_parser_got_current_pos(parser), "Unexpected EOF");
return nullptr;
}
scc_ast_type_t *type = ast_type_alloc();
const char *name = nullptr;
scc_ast_decl_t *decl = nullptr;
scc_ast_decl_vec_t member;
scc_vec_init(member);
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);
}
if (tok_ptr && tok_ptr->type == SCC_TOK_L_BRACE) {
scc_parser_next_consume(parser, nullptr);
while (1) {
@@ -708,12 +732,13 @@ static scc_ast_type_t *parse_enum_type(scc_parser_t *parser) {
enum_item_init = scc_parser_constant_expression(parser);
}
scc_ast_decl_t *enum_item_decl = scc_malloc(sizeof(scc_ast_decl_t));
scc_ast_decl_t *enum_item_decl =
SCC_AST_ALLOC_DECL(parser->ast_ctx);
Assert(enum_item_decl != nullptr);
scc_ast_decl_val_init(enum_item_decl, type,
scc_str_as_cstr(&tok.lexeme), enum_item_init,
tok.loc);
scc_vec_push(member, enum_item_decl);
scc_vec_push(decl->record.fields, enum_item_decl);
tok_ptr = scc_parser_peek(parser);
@@ -738,24 +763,17 @@ static scc_ast_type_t *parse_enum_type(scc_parser_t *parser) {
break;
}
}
decl = scc_malloc(sizeof(scc_ast_decl_t));
Assert(decl != nullptr);
scc_ast_decl_enum_init(decl, name, &member, pos);
scc_parse_decl_sema(parser, decl);
} else {
if (name == nullptr) {
SCC_ERROR(scc_parser_got_current_pos(parser),
"Expected name in enum specifier");
// FIXME memory leak
return nullptr;
}
}
scc_ast_type_enum_init(type, name, decl, pos);
scc_vec_foreach(decl->record.fields, i) {
scc_ast_decl_t *enum_decl = scc_vec_at(decl->record.fields, i);
scc_parse_decl_sema(parser, enum_decl);
}
return type;
}
static scc_ast_type_t *parse_type_specifier(scc_parser_t *parser) {
static scc_ast_qual_type_t *parse_type_specifier(scc_parser_t *parser) {
type_spec_info_t info = {0};
if (!scc_parse_is_type_specifier_start(parser))
return nullptr;
@@ -769,7 +787,7 @@ static scc_ast_type_t *parse_type_specifier(scc_parser_t *parser) {
switch (tok_ptr->type) {
case SCC_TOK_STRUCT:
case SCC_TOK_UNION:
info.user_type = parse_record_type(
info.user_type = parse_struct_union_type(
parser, tok_ptr->type == SCC_TOK_STRUCT ? SCC_AST_TYPE_STRUCT
: SCC_AST_TYPE_UNION);
goto done;
@@ -886,15 +904,15 @@ done:
if (!check_type_combinations(parser, &info)) {
return nullptr;
}
return build_type_from_info(&info, pos);
return build_type_from_info(parser, &info, pos);
duplicate_error:
SCC_ERROR(scc_parser_got_current_pos(parser), "Duplicate type specifier");
return nullptr;
}
static scc_ast_type_t *parse_pointer(scc_parser_t *parser,
scc_ast_type_t *pointee,
scc_ast_type_t **delay_pointee_ptr) {
static scc_ast_qual_type_t *
parse_pointer(scc_parser_t *parser, scc_ast_qual_type_t *pointee,
scc_ast_qual_type_t **delay_pointee_ptr) {
/*
pointer:
* type-qualifier-list(opt)
@@ -907,13 +925,15 @@ static scc_ast_type_t *parse_pointer(scc_parser_t *parser,
scc_pos_t pos = tok_ptr->loc;
scc_parser_next_consume(parser, nullptr);
scc_ast_type_t *pointer = ast_type_alloc();
scc_ast_qual_type_t *pointer = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
if (pointee == nullptr) {
Assert(delay_pointee_ptr != nullptr);
*delay_pointee_ptr = pointer;
pointee = pointer;
}
scc_ast_type_pointer_init(pointer, pointee, pos);
scc_ast_canon_type_t *canon = scc_ast_ctx_alloc_type(parser->ast_ctx);
scc_ast_type_pointer_init(pointer, canon, pointee, pos);
pointer->quals = parse_type_qualifier_list(parser, pointer->quals);
return parse_pointer(parser, pointer, delay_pointee_ptr);
@@ -937,7 +957,7 @@ static void parse_parameter_type_list(scc_parser_t *parser,
const scc_lexer_tok_t *tok_ptr = nullptr;
while (1) {
// FIXME
scc_ast_type_t *type = scc_parse_declaration_specifiers(parser);
scc_ast_qual_type_t *type = scc_parse_declaration_specifiers(parser);
if (type == nullptr) {
break;
}
@@ -947,7 +967,7 @@ static void parse_parameter_type_list(scc_parser_t *parser,
}
// TODO Check validation
param = scc_malloc(sizeof(scc_ast_decl_t));
param = SCC_AST_ALLOC_DECL(parser->ast_ctx);
Assert(param != nullptr);
scc_ast_decl_param_init(param, decl->var.type, decl->name,
scc_vec_size(*params), decl->base.loc);
@@ -964,12 +984,12 @@ 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_malloc(sizeof(scc_ast_decl_t));
param = SCC_AST_ALLOC_DECL(parser->ast_ctx);
Assert(param != nullptr);
// FIXME
type = scc_malloc(sizeof(scc_ast_type_t));
Assert(type != nullptr);
scc_ast_type_builtin_init(type, SCC_AST_BUILTIN_TYPE_VA_LIST,
type = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
scc_ast_type_builtin_init(type, parser->ast_ctx,
SCC_AST_BUILTIN_TYPE_VA_LIST,
tok_ptr->loc);
scc_ast_decl_param_init(param, type, nullptr, scc_vec_size(*params),
tok_ptr->loc);
@@ -1048,10 +1068,10 @@ static scc_ast_expr_t *parse_array_size_type(scc_parser_t *parser) {
return size;
}
static scc_ast_type_t *parse_declarator(scc_parser_t *parser,
scc_ast_type_t *base,
scc_ast_type_t **delay_pointee_ptr,
scc_lexer_tok_t *tok_ident) {
static scc_ast_qual_type_t *
parse_declarator(scc_parser_t *parser, scc_ast_qual_type_t *base,
scc_ast_qual_type_t **delay_pointee_ptr,
scc_lexer_tok_t *tok_ident) {
/*
(6.7.5) declarator:
pointer(opt) direct-declarator
@@ -1068,16 +1088,17 @@ static scc_ast_type_t *parse_declarator(scc_parser_t *parser,
direct-declarator ( parameter-type-list )
direct-declarator ( identifier-list(opt) )
*/
scc_ast_type_t *ret = parse_pointer(parser, base, delay_pointee_ptr);
scc_ast_qual_type_t *ret = parse_pointer(parser, base, delay_pointee_ptr);
return parse_direct_declarator(parser, ret, delay_pointee_ptr, tok_ident);
}
static scc_ast_type_t *
parse_direct_declarator(scc_parser_t *parser, scc_ast_type_t *base,
scc_ast_type_t **delay_pointee_ptr,
static scc_ast_qual_type_t *
parse_direct_declarator(scc_parser_t *parser, scc_ast_qual_type_t *base,
scc_ast_qual_type_t **delay_pointee_ptr,
scc_lexer_tok_t *tok_ident) {
const scc_lexer_tok_t *tok_ptr = nullptr;
scc_ast_type_t *ret = nullptr;
scc_ast_qual_type_t *ret = nullptr;
scc_ast_canon_type_t *canon = scc_ast_ctx_alloc_type(parser->ast_ctx);
// direct-abstract-declarator
tok_ptr = scc_parser_peek(parser);
if (tok_ptr == nullptr) {
@@ -1098,13 +1119,14 @@ parse_direct_declarator(scc_parser_t *parser, scc_ast_type_t *base,
} else if (tok_ptr->type == SCC_TOK_L_PAREN) {
// () SCC_TOK_L_PAREN
scc_parser_next_consume(parser, nullptr);
scc_ast_type_t *delay_pointee = nullptr;
scc_ast_qual_type_t *delay_pointee = nullptr;
if (parse_function_parameters_start(parser)) {
scc_ast_decl_vec_t params;
parse_function_parameters(parser, &params);
ret = ast_type_alloc();
ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
// FIXME
scc_ast_type_function_init(ret, base, &params, base->base.loc);
scc_ast_type_function_init(ret, canon, base, &params,
base->base.loc);
return parse_direct_declarator(parser, ret, delay_pointee_ptr,
tok_ident);
} else {
@@ -1118,28 +1140,28 @@ parse_direct_declarator(scc_parser_t *parser, scc_ast_type_t *base,
}
base = parse_direct_declarator(parser, base, delay_pointee_ptr,
tok_ident);
Assert(SCC_AST_IS_A(scc_ast_type_t, base));
Assert(SCC_AST_IS_A(scc_ast_qual_type_t, base));
Assert(delay_pointee != nullptr);
delay_pointee->pointer.pointee = base;
scc_ast_mut_canon_type(delay_pointee)->pointer.pointee = base;
return ret;
}
} 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_type_t *ret = ast_type_alloc();
scc_ast_qual_type_t *ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
base =
parse_direct_declarator(parser, base, delay_pointee_ptr, tok_ident);
// FIXME
scc_ast_type_array_init(ret, base, size, base->base.loc);
scc_ast_type_array_init(ret, canon, base, size, base->base.loc);
return ret;
} else {
return base;
}
}
static scc_ast_type_t *
parse_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
scc_ast_type_t **delay_pointee_ptr) {
static scc_ast_qual_type_t *
parse_abstract_declarator(scc_parser_t *parser, scc_ast_qual_type_t *base,
scc_ast_qual_type_t **delay_pointee_ptr) {
/*
(6.7.6) abstract-declarator:
pointer
@@ -1155,16 +1177,18 @@ parse_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
direct-abstract-declarator(opt) [ * ]
direct-abstract-declarator(opt) ( parameter-type-list(opt) )
*/
scc_ast_type_t *ret = parse_pointer(parser, base, delay_pointee_ptr);
scc_ast_qual_type_t *ret = parse_pointer(parser, base, delay_pointee_ptr);
ret = parse_direct_abstract_declarator(parser, ret, delay_pointee_ptr);
return ret;
}
static scc_ast_type_t *
parse_direct_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
scc_ast_type_t **delay_pointee_ptr) {
static scc_ast_qual_type_t *
parse_direct_abstract_declarator(scc_parser_t *parser,
scc_ast_qual_type_t *base,
scc_ast_qual_type_t **delay_pointee_ptr) {
const scc_lexer_tok_t *tok_ptr = nullptr;
scc_ast_type_t *ret = nullptr;
scc_ast_qual_type_t *ret = nullptr;
scc_ast_canon_type_t *canon = scc_ast_ctx_alloc_type(parser->ast_ctx);
// direct-abstract-declarator
tok_ptr = scc_parser_peek(parser);
if (tok_ptr == nullptr) {
@@ -1174,13 +1198,14 @@ parse_direct_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
if (tok_ptr->type == SCC_TOK_L_PAREN) {
// () SCC_TOK_L_PAREN
scc_parser_next_consume(parser, nullptr);
scc_ast_type_t *delay_pointee = nullptr;
scc_ast_qual_type_t *delay_pointee = nullptr;
if (parse_function_parameters_start(parser)) {
scc_ast_decl_vec_t params;
parse_function_parameters(parser, &params);
ret = ast_type_alloc();
ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
// FIXME
scc_ast_type_function_init(ret, base, &params, base->base.loc);
scc_ast_type_function_init(ret, canon, base, &params,
base->base.loc);
return parse_direct_abstract_declarator(parser, ret,
delay_pointee_ptr);
} else {
@@ -1192,17 +1217,17 @@ parse_direct_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
base = parse_direct_abstract_declarator(parser, base,
delay_pointee_ptr);
Assert(delay_pointee != nullptr);
delay_pointee->pointer.pointee = base;
scc_ast_mut_canon_type(delay_pointee)->pointer.pointee = base;
}
return ret;
} 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_type_t *ret = ast_type_alloc();
scc_ast_qual_type_t *ret = SCC_AST_ALLOC_QUAL_TYPE(parser->ast_ctx);
base =
parse_direct_abstract_declarator(parser, base, delay_pointee_ptr);
// FIXME
scc_ast_type_array_init(ret, base, size, base->base.loc);
scc_ast_type_array_init(ret, canon, base, size, base->base.loc);
return ret;
} else {
return base;
@@ -1210,12 +1235,12 @@ parse_direct_abstract_declarator(scc_parser_t *parser, scc_ast_type_t *base,
}
scc_ast_decl_t *scc_parse_declarator(scc_parser_t *parser,
scc_ast_type_t *type) {
scc_ast_qual_type_t *type) {
scc_lexer_tok_t decl_name_tok = {0};
scc_ast_type_t *decl_type =
scc_ast_qual_type_t *decl_type =
parse_declarator(parser, type, nullptr, &decl_name_tok);
scc_ast_decl_t *decl = nullptr;
decl = scc_malloc(sizeof(scc_ast_decl_t));
decl = SCC_AST_ALLOC_DECL(parser->ast_ctx);
Assert(decl != nullptr);
Assert(decl_name_tok.type == SCC_TOK_IDENT ||
decl_name_tok.type == SCC_TOK_UNKNOWN);
@@ -1240,36 +1265,39 @@ scc_ast_decl_t *scc_parse_declarator(scc_parser_t *parser,
}
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 (decl_type->record.decl == nullptr) {
decl = scc_malloc(sizeof(scc_ast_decl_t));
Assert(decl != nullptr);
if (decl_type->base.type == SCC_AST_TYPE_STRUCT) {
scc_ast_decl_struct_init(decl, 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, decl_type->record.name,
nullptr, decl_type->base.loc);
} else {
scc_ast_decl_enum_init(decl, type->record.name, nullptr,
decl_type->base.loc);
}
} else {
decl = decl_type->record.decl;
scc_free(decl_type); // FIXME
}
} else {
decl = scc_malloc(sizeof(scc_ast_decl_t));
scc_ast_decl_unsafe_val_init(decl, type, nullptr, nullptr,
decl_type->base.loc);
}
// 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);
// }
}
return decl;
}
scc_ast_type_t *scc_parse_declaration_specifiers(scc_parser_t *parser) {
scc_ast_qual_type_t *scc_parse_declaration_specifiers(scc_parser_t *parser) {
if (!scc_parse_is_decl_specifier_start(parser)) {
return nullptr;
}
@@ -1280,7 +1308,7 @@ scc_ast_type_t *scc_parse_declaration_specifiers(scc_parser_t *parser) {
}
spec = parse_declaration_specifiers_list(parser, spec);
scc_ast_type_t *specifier = parse_type_specifier(parser);
scc_ast_qual_type_t *specifier = parse_type_specifier(parser);
if (specifier == nullptr) {
SCC_ERROR(scc_parser_got_current_pos(parser),
"declaration specifier can't have type specifier");
@@ -1291,13 +1319,13 @@ scc_ast_type_t *scc_parse_declaration_specifiers(scc_parser_t *parser) {
return specifier;
}
scc_ast_type_t *scc_parse_type_name(scc_parser_t *parser) {
scc_ast_qual_type_t *scc_parse_type_name(scc_parser_t *parser) {
if (!(scc_parse_is_type_specifier_start(parser) ||
scc_parse_is_type_qualifier_start(parser))) {
return nullptr;
}
scc_ast_type_t *ret = nullptr;
scc_ast_qual_type_t *ret = nullptr;
scc_ast_decl_specifier_t spec = {0};
spec = parse_type_qualifier_list(parser, spec);
ret = parse_type_specifier(parser);

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

@@ -9,8 +9,8 @@ static void dummy_sema_callback(void *context, scc_ast_node_kind_t node_type,
return;
}
static scc_ast_type_t *dummy_got_type_callback(void *context,
const char *name) {
static const scc_ast_qual_type_t *dummy_got_type_callback(void *context,
const char *name) {
(void)context;
(void)name;
return nullptr;
@@ -20,8 +20,11 @@ static scc_ast_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_sema_callbacks_t *callbacks) {
scc_ast_ctx_t *ast_ctx, scc_sema_ctx_t *callbacks) {
Assert(parser != nullptr && tok_ring != nullptr);
Assert(ast_ctx != nullptr);
parser->ast_ctx = ast_ctx;
parser->ring = tok_ring;
parser->errcode = 0;
parser->translation_unit = nullptr;

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

@@ -1,13 +1,59 @@
#include <scc_ast_utils.h>
#include <scc_pos_log.h>
#include <scc_sema.h>
#include <sema_symtab.h>
static const scc_ast_qual_type_t *got_type_callback(void *context,
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:
*name = scc_str_from_cstr("$E_");
scc_str_append_cstr(name, decl->name, scc_strlen(decl->name));
break;
case SCC_AST_TYPE_STRUCT:
*name = scc_str_from_cstr("$S_");
scc_str_append_cstr(name, decl->name, scc_strlen(decl->name));
break;
case SCC_AST_TYPE_UNION:
*name = scc_str_from_cstr("$U_");
scc_str_append_cstr(name, decl->name, scc_strlen(decl->name));
break;
default:
break;
}
}
static void symtab_add_symbol(scc_sema_symtab_t *sema_symtab,
scc_ast_decl_t *decl,
scc_ast_node_t *ast_node_ref) {
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);
}
}
static void type_callback(void *context, scc_ast_node_kind_t node_type,
void *node) {
scc_sema_symtab_t *sema_symtab = context;
(void)context;
(void)node_type;
(void)node;
scc_ast_qual_type_t *type = SCC_AST_CAST_TO(scc_ast_qual_type_t, node);
if (node_type == SCC_AST_TYPE_STRUCT) {
symtab_add_symbol(sema_symtab, type->type->record.decl, &type->base);
} else if (node_type == SCC_AST_TYPE_UNION) {
symtab_add_symbol(sema_symtab, type->type->record.decl, &type->base);
} else if (node_type == SCC_AST_TYPE_ENUM) {
symtab_add_symbol(sema_symtab, type->type->record.decl, &type->base);
}
return;
}
@@ -71,119 +117,83 @@ static void decl_callback(void *context, scc_ast_node_kind_t node_type,
}
scc_ast_decl_t *decl = SCC_AST_CAST_TO(scc_ast_decl_t, node);
scc_ast_type_t *type = scc_malloc(sizeof(scc_ast_type_t));
Assert(type != nullptr);
if (node_type == SCC_AST_DECL_STRUCT) {
scc_ast_type_struct_init(type, decl->name, decl, decl->base.loc);
// FIXME memory leak
scc_str_t name = scc_str_from_cstr("$S_");
if (decl->name == nullptr) {
decl->name = "<anonymous struct>";
}
scc_str_append_cstr(&name, decl->name, scc_strlen(decl->name));
scc_sema_symtab_add_symbol(sema_symtab, scc_str_as_cstr(&name),
&type->base);
} else if (node_type == SCC_AST_DECL_UNION) {
scc_ast_type_union_init(type, decl->name, decl, decl->base.loc);
scc_str_t name = scc_str_from_cstr("$U_");
if (decl->name == nullptr) {
decl->name = "<anonymous union>";
}
scc_str_append_cstr(&name, decl->name, scc_strlen(decl->name));
scc_sema_symtab_add_symbol(sema_symtab, scc_str_as_cstr(&name),
&type->base);
} else if (node_type == SCC_AST_DECL_ENUM) {
scc_ast_type_enum_init(type, decl->name, decl, decl->base.loc);
scc_str_t name = scc_str_from_cstr("$E_");
if (decl->name == nullptr) {
decl->name = "<anonymous enum>";
}
scc_str_append_cstr(&name, decl->name, scc_strlen(decl->name));
scc_sema_symtab_add_symbol(sema_symtab, scc_str_as_cstr(&name),
&type->base);
scc_vec_foreach(decl->record.fields, i) {
scc_ast_decl_t *enum_decl = scc_vec_at(decl->record.fields, i);
scc_sema_symtab_add_symbol(sema_symtab, enum_decl->name,
&enum_decl->base);
// LOG_INFO("enum added %s", enum_decl->name);
}
} else if (node_type == SCC_AST_DECL_TYPEDEF) {
if (node_type == SCC_AST_DECL_TYPEDEF) {
if (decl->name == nullptr) {
SCC_ERROR(decl->base.loc, "typedef without name");
return;
}
scc_ast_type_typedef_init(type, decl->name, decl, decl->base.loc);
scc_sema_symtab_add_symbol(sema_symtab, decl->name, &type->base);
symtab_add_symbol(sema_symtab, decl, &decl->typedef_decl.type->base);
} else if (node_type == SCC_AST_DECL_VAR) {
scc_sema_symtab_add_symbol(sema_symtab, decl->name, &decl->base);
symtab_add_symbol(sema_symtab, decl, &decl->base);
} else if (node_type == SCC_AST_DECL_PARAM) {
if (decl->name == nullptr) {
if (decl->param.type->base.type == SCC_AST_TYPE_BUILTIN &&
(decl->param.type->builtin.type ==
(decl->param.type->type->builtin.type ==
SCC_AST_BUILTIN_TYPE_VA_LIST ||
decl->param.type->builtin.type == SCC_AST_BUILTIN_TYPE_VOID)) {
decl->param.type->type->builtin.type ==
SCC_AST_BUILTIN_TYPE_VOID)) {
return;
}
SCC_ERROR(decl->base.loc, "sema error: Parameter must have a name");
return;
}
scc_sema_symtab_add_symbol(sema_symtab, decl->name, &decl->base);
symtab_add_symbol(sema_symtab, decl, &decl->base);
} else if (node_type == SCC_AST_DECL_FUNC) {
if (decl->name == nullptr) {
SCC_ERROR(decl->base.loc, "sema error: Function must have a name");
} else {
// FIXME 重名函数...
scc_sema_symtab_add_symbol(sema_symtab, decl->name, &decl->base);
symtab_add_symbol(sema_symtab, decl, &decl->base);
}
}
return;
}
static scc_ast_type_t *got_type_callback(void *context, const char *name) {
static const scc_ast_qual_type_t *got_type_callback(void *context,
const char *name) {
scc_sema_symtab_t *sema_symtab = context;
scc_ast_node_t *node = scc_sema_symtab_lookup_symbol(sema_symtab, name);
if (SCC_AST_IS_A(scc_ast_type_t, node)) {
scc_ast_type_t *type = scc_malloc(sizeof(scc_ast_type_t));
*type = *(scc_ast_type_t *)node;
return type;
if (SCC_AST_IS_A(scc_ast_qual_type_t, node)) {
return (scc_ast_qual_type_t *)node;
}
return nullptr;
}
void scc_sema_init(scc_sema_callbacks_t *callbacks) {
void scc_sema_init(scc_sema_ctx_t *sema_ctx, scc_ast_ctx_t *ast_ctx) {
sema_ctx->ast_ctx = ast_ctx;
scc_sema_symtab_t *sema_symtab = scc_malloc(sizeof(scc_sema_symtab_t));
if (sema_symtab == nullptr) {
LOG_FATAL("out of memory");
return;
}
callbacks->context = sema_symtab;
callbacks->on_decl = decl_callback;
callbacks->on_expr = expr_callback;
callbacks->on_stmt = stmt_callback;
callbacks->on_type = type_callback;
callbacks->got_type = got_type_callback;
sema_ctx->context = sema_symtab;
sema_ctx->on_decl = decl_callback;
sema_ctx->on_expr = expr_callback;
sema_ctx->on_stmt = stmt_callback;
sema_ctx->on_type = type_callback;
sema_ctx->got_type = got_type_callback;
scc_sema_symtab_init(sema_symtab);
// FIXME memory leak
scc_ast_type_t *type = scc_malloc(sizeof(scc_ast_type_t));
scc_ast_type_builtin_init(type, SCC_AST_BUILTIN_TYPE_VA_LIST,
scc_pos_create());
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_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_malloc(sizeof(scc_ast_decl_t));
scc_ast_decl_t *decl = SCC_AST_ALLOC_DECL(sema_ctx->ast_ctx);
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_type_t *built_func_type = scc_malloc(sizeof(scc_ast_type_t));
scc_ast_type_function_init(built_func_type, nullptr, nullptr,
scc_pos_create());
scc_ast_decl_t *builin_func = scc_malloc(sizeof(scc_ast_decl_t));
scc_ast_qual_type_t *built_func_type =
SCC_AST_ALLOC_QUAL_TYPE(sema_ctx->ast_ctx);
// 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_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",
@@ -196,9 +206,9 @@ void scc_sema_init(scc_sema_callbacks_t *callbacks) {
&builin_func->base);
}
void scc_sema_drop(scc_sema_callbacks_t *callbacks) {
void scc_sema_drop(scc_sema_ctx_t *sema_ctx) {
// FIXME drop obj
if (callbacks->context) {
scc_sema_symtab_drop(callbacks->context);
if (sema_ctx->context) {
scc_sema_symtab_drop(sema_ctx->context);
}
}