scc/libs/ast/include/ast_def.h

#ifndef __SCC_AST_DEF_H__
#define __SCC_AST_DEF_H__

#include <scc_core.h>

/**
 * @brief AST 节点类型枚举
 */
typedef enum {
    // 声明
    scc_ast_decl_t_BEGIN, // 声明开始
    SCC_AST_DECL_VAR,     // 变量声明
    SCC_AST_DECL_FUNC,    // 函数声明
    SCC_AST_DECL_PARAM,   // 参数声明
    SCC_AST_DECL_STRUCT,  // 结构体声明
    SCC_AST_DECL_UNION,   // 联合声明
    SCC_AST_DECL_ENUM,    // 枚举声明
    SCC_AST_DECL_TYPEDEF, // typedef 声明
    scc_ast_decl_t_END,   // 声明结束

    // 语句
    scc_ast_stmt_t_BEGIN,  // 语句开始
    SCC_AST_STMT_COMPOUND, // 复合语句 { ... }
    SCC_AST_STMT_EXPR,     // 表达式语句
    SCC_AST_STMT_IF,       // if 语句
    SCC_AST_STMT_WHILE,    // while 语句
    SCC_AST_STMT_DO_WHILE, // do-while 语句
    SCC_AST_STMT_FOR,      // for 语句
    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 语句
    SCC_AST_STMT_RETURN,   // return 语句
    SCC_AST_STMT_GOTO,     // goto 语句
    SCC_AST_STMT_LABEL,    // 标签语句
    scc_ast_stmt_t_END,    // 结束语句

    // 表达式
    scc_ast_expr_t_BEGIN,          // 表达式开始
    SCC_AST_EXPR_BINARY,           // 二元运算
    SCC_AST_EXPR_UNARY,            // 一元运算
    SCC_AST_EXPR_COND,             // 条件表达式 ?:
    SCC_AST_EXPR_CALL,             // 函数调用
    SCC_AST_EXPR_ARRAY_SUBSCRIPT,  // 数组下标
    SCC_AST_EXPR_MEMBER,           // 成员访问 .
    SCC_AST_EXPR_PTR_MEMBER,       // 指针成员访问 ->
    SCC_AST_EXPR_CAST,             // 类型转换
    SCC_AST_EXPR_SIZE_OF,          // sizeof
    SCC_AST_EXPR_ALIGN_OF,         // _Alignof
    SCC_AST_EXPR_COMPOUND_LITERAL, // 复合字面量
    // 字面量
    SCC_AST_EXPR_INT_LITERAL,    // 整数字面量
    SCC_AST_EXPR_FLOAT_LITERAL,  // 浮点字面量
    SCC_AST_EXPR_CHAR_LITERAL,   // 字符字面量
    SCC_AST_EXPR_STRING_LITERAL, // 字符串字面量
    // 标识符
    SCC_AST_EXPR_IDENTIFIER, // 标识符
    scc_ast_expr_t_END,      // 表达式结束

    // 类型
    scc_ast_type_t_BEGIN,  // 类型开始
    SCC_AST_TYPE_BUILTIN,  // 内置类型
    SCC_AST_TYPE_POINTER,  // 指针类型
    SCC_AST_TYPE_ARRAY,    // 数组类型
    SCC_AST_TYPE_FUNCTION, // 函数类型
    SCC_AST_TYPE_STRUCT,   // 结构体类型
    SCC_AST_TYPE_UNION,    // 联合类型
    SCC_AST_TYPE_ENUM,     // 枚举类型
    SCC_AST_TYPE_TYPEDEF,  // typedef 类型
    scc_ast_type_t_END,    // 类型结束

    // 其他
    scc_ast_translation_unit_t_BEGIN,
    SCC_AST_TRANSLATION_UNIT, // 翻译单元（根节点）
    scc_ast_translation_unit_t_END,
} scc_ast_node_type_t;

typedef struct {
    scc_ast_node_type_t type;
    scc_pos_t loc;
} scc_ast_node_t;

#define SCC_AST_CAST_TO(kind, expr)                                            \
    ((kind *)(Assert(((scc_ast_node_t *)expr)->type > kind##_BEGIN &&          \
                     ((scc_ast_node_t *)expr)->type < kind##_END),             \
              (expr)))
#define SCC_AST_IS_A(kind, expr)                                               \
    ((expr) && (((scc_ast_node_t *)expr)->type > kind##_BEGIN &&               \
                ((scc_ast_node_t *)expr)->type < kind##_END))

/**
 * @brief 内置类型枚举
 */
typedef enum {
    TYPE_VOID,
    TYPE_CHAR,
    TYPE_SHORT,
    TYPE_INT,
    TYPE_LONG,
    TYPE_LONG_LONG,
    TYPE_FLOAT,
    TYPE_DOUBLE,
    TYPE_LONG_DOUBLE,
    TYPE_BOOL,
    TYPE_COMPLEX_FLOAT,
    TYPE_COMPLEX_DOUBLE,
    TYPE_COMPLEX_LONG_DOUBLE,
} scc_ast_builtin_type_t;

/**
 * @brief 限定符
 */
typedef struct {
    // storage-class-specifier
    cbool is_typedef;
    cbool is_extern;
    cbool is_static;
    cbool is_auto;
    cbool is_register;
    // type-qualifier
    cbool is_const;
    cbool is_volatile;
    cbool is_restrict;
    cbool is_atomic;
    // function-specifier
    cbool is_inline;
} scc_ast_decl_specifier_t;

// 前向声明
typedef struct scc_ast_type scc_ast_type_t;
typedef struct scc_ast_expr scc_ast_expr_t;
typedef struct scc_ast_stmt scc_ast_stmt_t;
typedef struct scc_ast_decl scc_ast_decl_t;

typedef SCC_VEC(scc_ast_type_t *) scc_ast_type_vec_t;
typedef SCC_VEC(scc_ast_expr_t *) scc_ast_expr_vec_t;
typedef SCC_VEC(scc_ast_stmt_t *) scc_ast_stmt_vec_t;
typedef SCC_VEC(scc_ast_decl_t *) scc_ast_decl_vec_t;

// 通过指针实现泛型 only stmt or decl
typedef SCC_VEC(scc_ast_node_t *) scc_ast_block_item_vec_t;

/**
 * @brief 类型表示
 */
struct scc_ast_type {
    scc_ast_node_t base;
    union {
        struct {
            scc_ast_builtin_type_t builtin;
            scc_ast_decl_specifier_t quals;
        } builtin;
        struct {
            scc_ast_type_t *pointee;
            scc_ast_decl_specifier_t quals;
        } pointer;
        struct {
            scc_ast_type_t *element;
            scc_ast_expr_t *size; // 可为 null <=> 不定长数组
        } array;
        struct {
            scc_ast_type_t *return_type;
            scc_ast_type_vec_t param_types;
            cbool is_variadic; // va_arg <=> ...
        } function;
        struct {
            const char *name;
            scc_ast_decl_vec_t fields; // 结构体/联合字段
        } record;
        struct {
            const char *name;
            scc_ast_expr_vec_t enumerators; // 枚举项
        } enumeration;
        struct {
            const char *name;
            scc_ast_type_t *underlying;
        } typedef_type;
    };
};

/**
 * @brief AST 操作符枚举
 * 这个枚举定义了所有在AST中使用的操作符，与词法token分离
 */
typedef enum scc_ast_expr_op {
    /* 无操作符 */
    SCC_AST_OP_NONE = 0,

    /* 赋值操作符 */
    SCC_AST_OP_ASSIGN,        // =
    SCC_AST_OP_ASSIGN_ADD,    // +=
    SCC_AST_OP_ASSIGN_SUB,    // -=
    SCC_AST_OP_ASSIGN_MUL,    // *=
    SCC_AST_OP_ASSIGN_DIV,    // /=
    SCC_AST_OP_ASSIGN_MOD,    // %=
    SCC_AST_OP_ASSIGN_AND,    // &=
    SCC_AST_OP_ASSIGN_XOR,    // ^=
    SCC_AST_OP_ASSIGN_OR,     // |=
    SCC_AST_OP_ASSIGN_LSHIFT, // <<=
    SCC_AST_OP_ASSIGN_RSHIFT, // >>=

    /* 条件操作符 */
    SCC_AST_OP_CONDITIONAL, // ?:

    /* 逻辑操作符 */
    SCC_AST_OP_LOGICAL_OR,  // ||
    SCC_AST_OP_LOGICAL_AND, // &&

    /* 位操作符 */
    SCC_AST_OP_BITWISE_OR,  // |
    SCC_AST_OP_BITWISE_XOR, // ^
    SCC_AST_OP_BITWISE_AND, // &

    /* 相等性操作符 */
    SCC_AST_OP_EQUAL,     // ==
    SCC_AST_OP_NOT_EQUAL, // !=

    /* 关系操作符 */
    SCC_AST_OP_LESS,          // <
    SCC_AST_OP_GREATER,       // >
    SCC_AST_OP_LESS_EQUAL,    // <=
    SCC_AST_OP_GREATER_EQUAL, // >=

    /* 移位操作符 */
    SCC_AST_OP_LEFT_SHIFT,  // <<
    SCC_AST_OP_RIGHT_SHIFT, // >>

    /* 算术操作符 */
    SCC_AST_OP_ADD, // +
    SCC_AST_OP_SUB, // -
    SCC_AST_OP_MUL, // *
    SCC_AST_OP_DIV, // /
    SCC_AST_OP_MOD, // %

    /* 一元操作符 */
    SCC_AST_OP_UNARY_PLUS,        // + (一元)
    SCC_AST_OP_UNARY_MINUS,       // - (一元)
    SCC_AST_OP_ADDRESS_OF,        // &
    SCC_AST_OP_INDIRECTION,       // *
    SCC_AST_OP_BITWISE_NOT,       // ~
    SCC_AST_OP_LOGICAL_NOT,       // !
    SCC_AST_OP_PREFIX_INCREMENT,  // ++ (前缀)
    SCC_AST_OP_PREFIX_DECREMENT,  // -- (前缀)
    SCC_AST_OP_POSTFIX_INCREMENT, // ++ (后缀)
    SCC_AST_OP_POSTFIX_DECREMENT, // -- (后缀)

    /* 成员访问 */
    SCC_AST_OP_MEMBER_ACCESS,     // .
    SCC_AST_OP_PTR_MEMBER_ACCESS, // ->
} scc_ast_expr_op_t;

/**
 * @brief 表达式节点
 */
struct scc_ast_expr {
    scc_ast_node_t base;
    union {
        // 二元运算
        struct {
            scc_ast_expr_op_t op;
            scc_ast_expr_t *lhs;
            scc_ast_expr_t *rhs;
        } binary;
        // 一元运算
        struct {
            scc_ast_expr_op_t op;
            scc_ast_expr_t *operand;
        } unary;
        // 条件表达式
        struct {
            scc_ast_expr_t *cond;
            scc_ast_expr_t *then_expr;
            scc_ast_expr_t *else_expr;
        } cond;
        // 函数调用
        struct {
            scc_ast_expr_t *callee;
            scc_ast_expr_vec_t args;
        } call;
        // 数组下标
        struct {
            scc_ast_expr_t *array;
            scc_ast_expr_t *index;
        } subscript;
        // 成员访问
        struct {
            scc_ast_expr_t *base;
            const char *member_name;
        } member;
        // 指针成员访问
        struct {
            scc_ast_expr_t *base;
            const char *member_name;
        } ptr_member;
        // 类型转换
        struct {
            scc_ast_type_t *type;
            scc_ast_expr_t *expr;
        } cast;
        // sizeof / _Alignof / ...
        union {
            scc_ast_type_t *type;
            scc_ast_expr_t *expr;
        } attr_of;
        // 复合字面量
        struct {
            scc_ast_type_t *type;
            scc_ast_expr_vec_t init_list;
        } compound_literal;
        // 字面量
        struct {
            scc_cvalue_t value;
        } literal;
        // 标识符
        struct {
            const char *name;
        } identifier;
    };
};

/**
 * @brief 语句节点
 */
struct scc_ast_stmt {
    scc_ast_node_t base;
    union {
        // 复合语句
        struct {
            scc_ast_block_item_vec_t block_items; // decl or stmt
        } compound;
        // 表达式语句
        struct {
            scc_ast_expr_t *expr;
        } expr;
        // if 语句
        struct {
            scc_ast_expr_t *cond;
            scc_ast_stmt_t *then_stmt;
            scc_ast_stmt_t *opt_else_stmt; // stmt or null
        } if_stmt;
        // while 语句
        struct {
            scc_ast_expr_t *cond;
            scc_ast_stmt_t *body;
        } while_stmt;
        // do-while 语句
        struct {
            scc_ast_stmt_t *body;
            scc_ast_expr_t *cond;
        } do_while_stmt;
        // for 语句
        struct {
            scc_ast_type_t *init; // expr or decl or null
            scc_ast_expr_t *cond; // 可为 null
            scc_ast_expr_t *iter; // 可为 null
            scc_ast_stmt_t *body;
        } for_stmt;
        // switch 语句
        struct {
            scc_ast_expr_t *cond;
            scc_ast_stmt_t *body;
        } switch_stmt;
        // case 语句
        struct {
            scc_ast_expr_t *expr;
            scc_ast_stmt_t *stmt;
        } case_stmt;
        // default 语句
        struct {
            scc_ast_stmt_t *stmt;
        } default_stmt;
        // break/continue
        struct {
            // 无额外字段
        } jump;
        // return 语句
        struct {
            scc_ast_expr_t *expr; // 可为 NULL
        } return_stmt;
        // goto 语句
        struct {
            const char *label;
        } goto_stmt;
        // 标签语句
        struct {
            const char *label;
            scc_ast_stmt_t *stmt;
        } label_stmt;
    };
};

/**
 * @brief 声明节点
 */
struct scc_ast_decl {
    scc_ast_node_t base;
    union {
        // 变量声明
        struct {
            const char *name;
            scc_ast_type_t *type;
            scc_ast_expr_t *init; // 可为 NULL
        } var;
        // 函数声明
        struct {
            const char *name;
            scc_ast_type_t *type; // 函数类型
            scc_ast_stmt_t *body; // 可为 NULL（只有声明） or
        } func;
        // 参数声明
        struct {
            const char *name;
            scc_ast_type_t *type;
        } param;
        // 结构体/联合声明
        struct {
            const char *name;
            scc_ast_decl_vec_t fields;
        } record;
        // 枚举声明
        struct {
            const char *name;
            scc_ast_expr_vec_t enumerators;
        } enumeration;
        // typedef 声明
        struct {
            const char *name;
            scc_ast_type_t *type;
        } typedef_decl;
    };
};

/**
 * @brief 翻译单元节点（根节点）
 */
typedef struct scc_ast_translation_unit {
    scc_ast_node_t base;
    scc_ast_decl_vec_t declarations;
} scc_ast_translation_unit_t;

#endif /* __SCC_AST_DEF_H__ */