#include "parser.h" #include "ast_printer.h" #include #include #include char* token_type_to_string(TokenType type) { switch (type) { case TOKEN_EOF: return "eof"; case TOKEN_IDENTIFIER: return "identifier"; case TOKEN_INT: return "int"; case TOKEN_FLOAT: return "float"; case TOKEN_STRING: return "string"; case TOKEN_KEYWORD: return "keyword"; case TOKEN_ASSIGN: return "="; case TOKEN_PLUS: return "+"; case TOKEN_MINUS: return "-"; case TOKEN_MUL: return "*"; case TOKEN_DIV: return "/"; case TOKEN_MOD: return "%"; case TOKEN_PLUS_PLUS: return "++"; case TOKEN_MINUS_MINUS: return "--"; case TOKEN_LPAREN: return "("; case TOKEN_RPAREN: return ")"; case TOKEN_LBRACE: return "{"; case TOKEN_RBRACE: return "}"; case TOKEN_LBRACKET: return "["; case TOKEN_RBRACKET: return "]"; case TOKEN_COMMA: return ","; case TOKEN_SEMICOLON: return ";"; case TOKEN_COLON: return ":"; case TOKEN_DOT: return "."; case TOKEN_LT: return "<"; case TOKEN_GT: return ">"; case TOKEN_LE: return "<="; case TOKEN_GE: return ">="; case TOKEN_EQ: return "="; case TOKEN_EQ_EQ: return "=="; case TOKEN_NE: return "!="; case TOKEN_AND: return "and"; case TOKEN_OR: return "or"; case TOKEN_NOT: return "not"; case TOKEN_BITAND: return "&"; case TOKEN_BITOR: return "|"; case TOKEN_BITXOR: return "^"; case TOKEN_TILDE: return "~"; case TOKEN_SHL: return "<<"; case TOKEN_SHR: return ">>"; case TOKEN_IF: return "if"; case TOKEN_ELSE: return "else"; case TOKEN_WHILE: return "while"; case TOKEN_FOR: return "for"; case TOKEN_RETURN: return "return"; case TOKEN_BREAK: return "break"; case TOKEN_CONTINUE: return "continue"; case TOKEN_LET: return "let"; case TOKEN_CONST: return "const"; case TOKEN_TRUE: return "true"; case TOKEN_FALSE: return "false"; case TOKEN_NULL: return "null"; case TOKEN_IMPORT: return "import"; case TOKEN_AS: return "as"; case TOKEN_IN: return "in"; case TOKEN_NATIVE: return "native"; case TOKEN_FUNC: return "func"; case TOKEN_BOOL: return "bool"; case TOKEN_MAP: return "map"; case TOKEN_ARRAY: return "array"; case TOKEN_INT_LITERAL: return "int_literal"; case TOKEN_FLOAT_LITERAL: return "float_literal"; case TOKEN_STRING_LITERAL: return "string_literal"; case TOKEN_BOOL_LITERAL: return "bool_literal"; case TOKEN_STAR: return "*"; case TOKEN_SLASH: return "/"; case TOKEN_BANG: return "!"; case TOKEN_AT: return "@"; case TOKEN_THROW: return "throw"; case TOKEN_ERROR: return "error"; default: return "unknown" ; } } void parser_init(Parser* parser, Lexer* lexer, char* filename) { parser->lexer = lexer; parser->filename = filename; parser->had_error = 0; parser->error_count = 0; parser->errors = NULL; parser->current_token = lexer_next_token(lexer); } void parser_free(Parser* parser) { free(parser->filename); // 释放错误信息数组 if (parser->errors) { for (int i = 0; i < parser->error_count; i++) { free(parser->errors[i].message); } free(parser->errors); } } Token consume_token(Parser* parser) { Token previous_token = parser->current_token; parser->current_token = lexer_next_token(parser->lexer); return previous_token; } int match_token(Parser* parser, TokenType type) { return parser->current_token.type == type; } Token expect_token(Parser* parser, TokenType type) { if (!match_token(parser, type)) { char message[256]; snprintf(message, sizeof(message), "Expected '%s', got '%s'", token_type_to_string(type), token_type_to_string(parser->current_token.type)); parser_error_at_current(parser, message); } return consume_token(parser); } // 解析函数 /* * func func_name(p: int): int {} */ ASTNode* parse_function_declaration(Parser* parser) { ASTNode* node = create_node(NODE_FUNC_DECL); set_node_position(node, parser->lexer->line, parser->lexer->column); // 处理native修饰符 if (match_token(parser, TOKEN_NATIVE)) { consume_token(parser); node->value = strdup("native"); } else { node->value = NULL; } // 解析func关键字 expect_token(parser, TOKEN_FUNC); // 解析函数名 Token identifier = consume_token(parser); ASTNode* id_node = create_node(NODE_IDENTIFIER); set_node_position(id_node, identifier.line, identifier.column); id_node->value = strdup(identifier.value); add_child(node, id_node); // 解析参数列表 expect_token(parser, TOKEN_LPAREN); ASTNode* params_node = create_node(NODE_PARAM_LIST); set_node_position(params_node, parser->lexer->line, parser->lexer->column); while (!match_token(parser, TOKEN_RPAREN)) { // 创建单个参数节点 ASTNode* param_node = create_node(NODE_PARAM); set_node_position(param_node, parser->lexer->line, parser->lexer->column); // 解析参数名 Token param = consume_token(parser); ASTNode* id_node = create_node(NODE_IDENTIFIER); set_node_position(id_node, param.line, param.column); id_node->value = strdup(param.value); add_child(param_node, id_node); // 处理类型 if (match_token(parser, TOKEN_COLON)) { consume_token(parser); Token type = consume_token(parser); ASTNode* type_node = create_node(NODE_TYPE_IDENTIFIER); type_node->value = strdup(type.value); set_node_position(type_node, type.line, type.column); // 处理数组类型 while (match_token(parser, TOKEN_LBRACKET)) { consume_token(parser); // 消费左中括号 type_node->type = NODE_ARRAY_TYPE; // 解析数组大小（如果有） if (!match_token(parser, TOKEN_RBRACKET)) { Token size_token = consume_token(parser); ASTNode* size_node = create_node(NODE_INT_LITERAL); size_node->value = strdup(size_token.value); set_node_position(size_node, size_token.line, size_token.column); add_child(type_node, size_node); } expect_token(parser, TOKEN_RBRACKET); } add_child(param_node, type_node); } // 将参数节点添加到参数列表 add_child(params_node, param_node); // 处理逗号 if (match_token(parser, TOKEN_COMMA)) { consume_token(parser); } else { break; } } expect_token(parser, TOKEN_RPAREN); add_child(node, params_node); // 处理返回值类型 if (match_token(parser, TOKEN_COLON)) { consume_token(parser); Token return_type = consume_token(parser); ASTNode* return_type_node = create_node(NODE_TYPE_IDENTIFIER); return_type_node->value = strdup(return_type.value); set_node_position(return_type_node, return_type.line, return_type.column); // 处理数组类型 while (match_token(parser, TOKEN_LBRACKET)) { consume_token(parser); // 消费左中括号 return_type_node->type = NODE_ARRAY_TYPE; // 标记为数组类型 // 解析数组大小（如果有） if (!match_token(parser, TOKEN_RBRACKET)) { Token size_token = consume_token(parser); ASTNode* size_node = create_node(NODE_INT_LITERAL); size_node->value = strdup(size_token.value); set_node_position(size_node, size_token.line, size_token.column); add_child(return_type_node, size_node); } expect_token(parser, TOKEN_RBRACKET); } add_child(node, return_type_node); } // 处理分号或函数体 if (match_token(parser, TOKEN_SEMICOLON)) { consume_token(parser); } else { // 解析函数体 ASTNode* body = parse_block(parser); if (body != NULL) { add_child(node, body); } } return node; } // 解析变量申明 // let/const var: int/空 = exp ASTNode* parse_var_declaration(Parser* parser) { // 记录声明类型（let/const） char* decl_type; if (match_token(parser, TOKEN_LET)) { consume_token(parser); decl_type = strdup("let"); } else if (match_token(parser, TOKEN_CONST)) { consume_token(parser); decl_type = strdup("const"); } else { parser_error_at_current(parser, "Expected let or const"); return NULL; } // 创建第一个变量声明节点 ASTNode* first_var = create_node(NODE_VAR_DECL); set_node_position(first_var, parser->lexer->line, parser->lexer->column); first_var->value = decl_type; // 获取标识符 Token identifier = consume_token(parser); ASTNode* id_node = create_node(NODE_IDENTIFIER); set_node_position(id_node, identifier.line, identifier.column); id_node->value = strdup(identifier.value); add_child(first_var, id_node); // 处理类型 ASTNode* type_node = NULL; if (match_token(parser, TOKEN_COLON)) { consume_token(parser); // 消费冒号 // 解析类型标识符 Token type = consume_token(parser); type_node = create_node(NODE_TYPE_IDENTIFIER); type_node->value = strdup(type.value); set_node_position(type_node, type.line, type.column); // 处理数组类型 while (match_token(parser, TOKEN_LBRACKET)) { consume_token(parser); // 消费左中括号 type_node->type = NODE_ARRAY_TYPE; // 标记为数组类型 // 解析数组大小（如果有） if (!match_token(parser, TOKEN_RBRACKET)) { Token size_token = consume_token(parser); ASTNode* size_node = create_node(NODE_INT_LITERAL); size_node->value = strdup(size_token.value); set_node_position(size_node, size_token.line, size_token.column); add_child(type_node, size_node); } expect_token(parser, TOKEN_RBRACKET); } // 处理泛型类型参数 if (match_token(parser, TOKEN_LT)) { consume_token(parser); // 消费 < ASTNode* generic_params = create_node(NODE_GENERIC_PARAMS); set_node_position(generic_params, parser->lexer->line, parser->lexer->column); do { Token param = consume_token(parser); ASTNode* param_node = create_node(NODE_TYPE_IDENTIFIER); param_node->value = strdup(param.value); set_node_position(param_node, param.line, param.column); add_child(generic_params, param_node); if (match_token(parser, TOKEN_COMMA)) { consume_token(parser); } } while (!match_token(parser, TOKEN_GT)); expect_token(parser, TOKEN_GT); add_child(type_node, generic_params); } add_child(first_var, type_node); } // 处理值 if (match_token(parser, TOKEN_EQ)) { consume_token(parser); // 消费等号 // 解析初始化表达式 ASTNode* init_expr = parse_expression(parser); if (init_expr != NULL) { add_child(first_var, init_expr); // 如果没有显式类型注解，根据初始化表达式推断类型 if (type_node == NULL) { type_node = create_node(NODE_TYPE_IDENTIFIER); set_node_position(type_node, init_expr->line, init_expr->column); // 根据表达式类型推断变量类型 switch (init_expr->type) { case NODE_INT_LITERAL: type_node->value = strdup("i32"); // 默认整数类型为i32 break; case NODE_FLOAT_LITERAL: type_node->value = strdup("f64"); // 默认浮点类型为f64 break; case NODE_STRING_LITERAL: type_node->value = strdup("string"); break; case NODE_BOOL_LITERAL: type_node->value = strdup("bool"); break; case NODE_ARRAY_LITERAL: type_node->value = strdup("array"); break; case NODE_MAP_LITERAL: type_node->value = strdup("map"); break; default: type_node->value = strdup("any"); } add_child(first_var, type_node); } } } // 检查是否有更多变量声明 if (!match_token(parser, TOKEN_COMMA)) { // 单变量声明，直接返回 if (match_token(parser, TOKEN_SEMICOLON)) { consume_token(parser); } return first_var; } // 多变量声明，创建列表节点 ASTNode* list_node = create_node(NODE_VAR_DECL_LIST); set_node_position(list_node, parser->lexer->line, parser->lexer->column); list_node->value = decl_type; add_child(list_node, first_var); // 处理后续变量 while (match_token(parser, TOKEN_COMMA)) { consume_token(parser); // 消费逗号 ASTNode* var_node = create_node(NODE_VAR_DECL); set_node_position(var_node, parser->lexer->line, parser->lexer->column); var_node->value = strdup(decl_type); // 获取标识符 identifier = consume_token(parser); id_node = create_node(NODE_IDENTIFIER); set_node_position(id_node, identifier.line, identifier.column); id_node->value = strdup(identifier.value); add_child(var_node, id_node); // 处理类型 if (match_token(parser, TOKEN_COLON)) { consume_token(parser); // 消费冒号 Token type = consume_token(parser); ASTNode* type_node = create_node(NODE_TYPE_IDENTIFIER); type_node->value = strdup(type.value); set_node_position(type_node, type.line, type.column); // 处理数组维度 if (match_token(parser, TOKEN_LBRACKET)) { consume_token(parser); // 消费左中括号 // 解析数组大小 if (!match_token(parser, TOKEN_RBRACKET)) { Token size_token = consume_token(parser); ASTNode* size_node = create_node(NODE_INT_LITERAL); size_node->value = strdup(size_token.value); set_node_position(size_node, size_token.line, size_token.column); add_child(type_node, size_node); } expect_token(parser, TOKEN_RBRACKET); } add_child(var_node, type_node); } // 处理值 if (match_token(parser, TOKEN_EQ)) { consume_token(parser); // 消费等号 ASTNode* init_expr = parse_expression(parser); if (init_expr != NULL) { add_child(var_node, init_expr); } } add_child(list_node, var_node); } // 可选择的分号 if (match_token(parser, TOKEN_SEMICOLON)) { consume_token(parser); } return list_node; } // 解析键值对字面量 /* * {a:6} */ ASTNode* parse_key_value_literal(Parser* parser) { ASTNode* node = create_node(NODE_MAP_LITERAL); set_node_position(node, parser->lexer->line, parser->lexer->column); // 解析左大括号 expect_token(parser, TOKEN_LBRACE); // 解析键值对 do { // 创建键值对节点 ASTNode* entry_node = create_node(NODE_MAP_ENTRY); set_node_position(entry_node, parser->lexer->line, parser->lexer->column); // 解析键 Token key = consume_token(parser); ASTNode* key_node = create_node(NODE_IDENTIFIER); set_node_position(key_node, key.line, key.column); key_node->value = strdup(key.value); add_child(entry_node, key_node); // 解析冒号 expect_token(parser, TOKEN_COLON); // 解析值 ASTNode* value_node = parse_expression(parser); add_child(entry_node, value_node); // 将键值对节点添加到主节点 add_child(node, entry_node); // 处理逗号 if (match_token(parser, TOKEN_COMMA)) { consume_token(parser); // 消费逗号 } } while (!match_token(parser, TOKEN_RBRACE)); expect_token(parser, TOKEN_RBRACE); return node; } // 解析数组字面量 /* * [1, 2, 3] */ ASTNode* parse_array_literal(Parser* parser) { ASTNode* node = create_node(NODE_ARRAY_LITERAL); set_node_position(node, parser->lexer->line, parser->lexer->column); // 解析左中括号 expect_token(parser, TOKEN_LBRACKET); // 解析元素 do { // 创建数组元素节点 //ASTNode* item_node = create_node(NODE_ARRAY_ITEM); //set_node_position(item_node, parser->lexer->line, parser->lexer->column); // 解析元素值 ASTNode* value_node = parse_expression(parser); add_child(node, value_node); // 将元素节点添加到数组 //add_child(node, item_node); // 处理逗号 if (match_token(parser, TOKEN_COMMA)) { consume_token(parser); // 消费逗号 } } while (!match_token(parser, TOKEN_RBRACKET)); expect_token(parser, TOKEN_RBRACKET); return node; } // 解析try-catch语句 /* * try { * // code * } catch (e) { * // handler * } */ // 解析try-catch结构 ASTNode* parse_try_catch_statement(Parser* parser) { ASTNode* node = create_node(NODE_TRY_STMT); set_node_position(node, parser->lexer->line, parser->lexer->column); // 解析try块 expect_token(parser, TOKEN_TRY); ASTNode* try_block = parse_block(parser); add_child(node, try_block); // 解析catch块 expect_token(parser, TOKEN_CATCH); expect_token(parser, TOKEN_LPAREN); // 解析异常变量 Token exception_var = expect_token(parser, TOKEN_IDENTIFIER); ASTNode* var_node = create_node(NODE_IDENTIFIER); set_node_position(var_node, exception_var.line, exception_var.column); var_node->value = strdup(exception_var.value); // 创建catch块节点 ASTNode* catch_node = create_node(NODE_CATCH_BLOCK); set_node_position(catch_node, parser->lexer->line, parser->lexer->column); add_child(catch_node, var_node); expect_token(parser, TOKEN_RPAREN); ASTNode* catch_block = parse_block(parser); add_child(catch_node, catch_block); add_child(node, catch_node); return node; } ASTNode* parse_block(Parser* parser) { ASTNode* node = create_node(NODE_BLOCK); set_node_position(node, parser->lexer->line, parser->lexer->column); expect_token(parser, TOKEN_LBRACE); while (!match_token(parser, TOKEN_RBRACE) && !match_token(parser, TOKEN_EOF)) { ASTNode* stmt = parse_statement(parser); if (stmt != NULL) { add_child(node, stmt); } } expect_token(parser, TOKEN_RBRACE); return node; } // 解析if语句 /* * if (a >= 6 or b >= 7) {...} else if (a > 7) {...} else {...} * 等价于 * if (a >= 6 or b >= 7) {...} else { * if (a > 7) {...} else {...} * } */ ASTNode* parse_if_statement(Parser* parser) { ASTNode* node = create_node(NODE_IF_STMT); set_node_position(node, parser->lexer->line, parser->lexer->column); expect_token(parser, TOKEN_IF); expect_token(parser, TOKEN_LPAREN); // 解析条件表达式 ASTNode* cond_expr = parse_expression(parser); add_child(node, cond_expr); expect_token(parser, TOKEN_RPAREN); // 解析if体 if (match_token(parser, TOKEN_LBRACE)) { ASTNode* if_body = parse_block(parser); add_child(node, if_body); } // 处理else if和else while (match_token(parser, TOKEN_ELSE)) { consume_token(parser); // 消费else if (match_token(parser, TOKEN_IF)) { // 处理else if分支 consume_token(parser); // 消费if ASTNode* else_if_node = create_node(NODE_ELSE_IF); set_node_position(else_if_node, parser->lexer->line, parser->lexer->column); expect_token(parser, TOKEN_LPAREN); ASTNode* else_if_cond = parse_expression(parser); add_child(else_if_node, else_if_cond); expect_token(parser, TOKEN_RPAREN); if (match_token(parser, TOKEN_LBRACE)) { ASTNode* else_if_body = parse_block(parser); add_child(else_if_node, else_if_body); } add_child(node, else_if_node); } else if (match_token(parser, TOKEN_LBRACE)) { // 处理else分支 ASTNode* else_node = create_node(NODE_ELSE_BLOCK); set_node_position(else_node, parser->lexer->line, parser->lexer->column); ASTNode* else_body = parse_block(parser); add_child(else_node, else_body); add_child(node, else_node); break; } } return node; } // 解析for语句 /* * for (let i:int = 0, j:int = 0; i < 10; i++) {...} */ ASTNode* parse_for_statement(Parser* parser) { ASTNode* node = create_node(NODE_FOR_STMT); set_node_position(node, parser->lexer->line, parser->lexer->column); expect_token(parser, TOKEN_FOR); expect_token(parser, TOKEN_LPAREN); // 解析初始化语句 ASTNode* init_list = create_node(NODE_FOR_INIT); set_node_position(init_list, parser->lexer->line, parser->lexer->column); ASTNode* init_stmt = parse_statement(parser); add_child(init_list, init_stmt); add_child(node, init_list); // 解析条件表达式 ASTNode* cond_node = create_node(NODE_FOR_CONDITION); set_node_position(cond_node, parser->lexer->line, parser->lexer->column); if (!match_token(parser, TOKEN_SEMICOLON)) { ASTNode* cond_expr = parse_expression(parser); add_child(cond_node, cond_expr); } else { ASTNode* empty_expr = create_node(NODE_EXPR_STMT); set_node_position(empty_expr, parser->lexer->line, parser->lexer->column); add_child(cond_node, empty_expr); } add_child(node, cond_node); // 解析更新语句 ASTNode* update_node = create_node(NODE_FOR_UPDATE); set_node_position(update_node, parser->lexer->line, parser->lexer->column); if (!match_token(parser, TOKEN_RPAREN)) { ASTNode* update_stmt = parse_expression(parser); add_child(update_node, update_stmt); } else { ASTNode* empty_stmt = create_node(NODE_EXPR_STMT); set_node_position(empty_stmt, parser->lexer->line, parser->lexer->column); add_child(update_node, empty_stmt); } add_child(node, update_node); expect_token(parser, TOKEN_RPAREN); // 解析循环体 ASTNode* body = parse_block(parser); add_child(node, body); return node; } // 解析while语句 ASTNode* parse_while_statement(Parser* parser) { ASTNode* node = create_node(NODE_WHILE_STMT); set_node_position(node, parser->lexer->line, parser->lexer->column); expect_token(parser, TOKEN_WHILE); expect_token(parser, TOKEN_LPAREN); // 解析条件表达式 ASTNode* cond_expr = parse_expression(parser); add_child(node, cond_expr); expect_token(parser, TOKEN_RPAREN); // 解析循环体 ASTNode* body = parse_block(parser); add_child(node, body); return node; } ASTNode* parse_expression_statement(Parser* parser) { //ASTNode* node = create_node(NODE_EXPR_STMT); //set_node_position(node, parser->lexer->line, parser->lexer->column); ASTNode* expr = parse_expression(parser); set_node_position(expr, parser->lexer->line, parser->lexer->column); //add_child(node, expr); if (match_token(parser, TOKEN_SEMICOLON)) consume_token(parser); return expr; } // 解析return语句 ASTNode* parse_return_statement(Parser* parser) { ASTNode* node = create_node(NODE_RETURN_STMT); set_node_position(node, parser->lexer->line, parser->lexer->column); expect_token(parser, TOKEN_RETURN); // 如果有返回值 if (!match_token(parser, TOKEN_SEMICOLON)) add_child(node, parse_expression(parser)); if (match_token(parser, TOKEN_SEMICOLON)) consume_token(parser); return node; } ASTNode* parse_break_statement(Parser* parser) { ASTNode* node = create_node(NODE_BREAK_STMT); set_node_position(node, parser->lexer->line, parser->lexer->column); expect_token(parser, TOKEN_BREAK); if (match_token(parser, TOKEN_SEMICOLON)) consume_token(parser); return node; } ASTNode* parse_continue_statement(Parser* parser) { ASTNode* node = create_node(NODE_CONTINUE_STMT); set_node_position(node, parser->lexer->line, parser->lexer->column); expect_token(parser, TOKEN_CONTINUE); if (match_token(parser, TOKEN_SEMICOLON)) consume_token(parser); return node; } ASTNode* parse_import_statement(Parser* parser) { ASTNode* node = create_node(NODE_IMPORT_STMT); set_node_position(node, parser->lexer->line, parser->lexer->column); expect_token(parser, TOKEN_IMPORT); // 解析导入路径 ASTNode* path_node = create_node(NODE_IMPORT_PATH); set_node_position(path_node, parser->lexer->line, parser->lexer->column); // 解析第一个标识符 Token identifier = consume_token(parser); ASTNode* id_node = create_node(NODE_IDENTIFIER); set_node_position(id_node, identifier.line, identifier.column); id_node->value = strdup(identifier.value); add_child(path_node, id_node); // 解析后续的路径部分 while (match_token(parser, TOKEN_DOT)) { consume_token(parser); // 消费点号 // 处理连续的点号（..） if (match_token(parser, TOKEN_DOT)) { consume_token(parser); // 消费第二个点号 ASTNode* parent_dir_node = create_node(NODE_IMPORT_PATH); set_node_position(parent_dir_node, parser->lexer->line, parser->lexer->column); add_child(path_node, parent_dir_node); } else { // 解析常规路径部分 identifier = consume_token(parser); id_node = create_node(NODE_IDENTIFIER); set_node_position(id_node, identifier.line, identifier.column); id_node->value = strdup(identifier.value); add_child(path_node, id_node); } } add_child(node, path_node); // 处理别名（as） if (match_token(parser, TOKEN_AS)) { consume_token(parser); // 消费as关键字 Token alias = consume_token(parser); ASTNode* alias_node = create_node(NODE_IMPORT_ALIAS); set_node_position(alias_node, alias.line, alias.column); alias_node->value = strdup(alias.value); add_child(node, alias_node); } if (match_token(parser, TOKEN_SEMICOLON)) consume_token(parser); return node; } // 解析注解 /* * @name 或 @name(param1, param2, ...) 或 @name(key1=value1, key2=value2, ...) */ ASTNode* parse_annotation(Parser* parser) { ASTNode* node = create_node(NODE_ANNOTATION); set_node_position(node, parser->lexer->line, parser->lexer->column); // 解析@符号 expect_token(parser, TOKEN_AT); // 解析注解名称 Token name = expect_token(parser, TOKEN_IDENTIFIER); node->value = strdup(name.value); // 解析可选的参数列表 if (match_token(parser, TOKEN_LPAREN)) { consume_token(parser); // 消费左括号 // 解析参数 while (!match_token(parser, TOKEN_RPAREN)) { // 检查是否是命名参数 (name=value形式) if (match_token(parser, TOKEN_IDENTIFIER)) { Token identifier = parser->current_token; consume_token(parser); // 检查是否有等号 if (match_token(parser, TOKEN_EQ)) { consume_token(parser); // 消费等号 // 创建命名参数节点 ASTNode* named_arg = create_node(NODE_NAMED_ARG); set_node_position(named_arg, identifier.line, identifier.column); // 添加参数名 ASTNode* name_node = create_node(NODE_IDENTIFIER); set_node_position(name_node, identifier.line, identifier.column); name_node->value = strdup(identifier.value); add_child(named_arg, name_node); // 解析参数值 ASTNode* value = parse_expression_with_precedence(parser, PREC_NONE); add_child(named_arg, value); // 将命名参数添加到注解 add_child(node, named_arg); } else { // 不是命名参数，回退并按普通参数处理 parser->lexer->current_pos--; // 回退pos parser->lexer->column = parser->lexer->column - strlen(identifier.value); parser->current_token = identifier; // 回退token ASTNode* param = parse_expression(parser); add_child(node, param); } } else { // 普通参数 ASTNode* pos_arg = create_node(NODE_POS_ARG); set_node_position(pos_arg, parser->lexer->line, parser->lexer->column); // 解析参数值 ASTNode* value = parse_expression(parser); add_child(pos_arg, value); // 将位置参数添加到注解节点 add_child(node, pos_arg); } // 处理逗号 if (match_token(parser, TOKEN_COMMA)) { consume_token(parser); // 消费逗号 } else { break; } } expect_token(parser, TOKEN_RPAREN); // 消费右括号 } return node; } // 解析语句 ASTNode* parse_statement(Parser* parser) { // 处理注解（支持多个注解） ASTNode* annotations = create_node(NODE_ANNOTATIONS); set_node_position(annotations, parser->lexer->line, parser->lexer->column); // 循环处理所有连续的注解 while (match_token(parser, TOKEN_AT)) { ASTNode* current_annotation = parse_annotation(parser); add_child(annotations, current_annotation); } // 解析实际语句 ASTNode* stmt = NULL; if (match_token(parser, TOKEN_LET) || match_token(parser, TOKEN_CONST)) { stmt = parse_var_declaration(parser); } else if (match_token(parser, TOKEN_FUNC) || match_token(parser, TOKEN_NATIVE)) { stmt = parse_function_declaration(parser); } else if (match_token(parser, TOKEN_IF)) { stmt = parse_if_statement(parser); } else if (match_token(parser, TOKEN_FOR)) { stmt = parse_for_statement(parser); } else if (match_token(parser, TOKEN_WHILE)) { stmt = parse_while_statement(parser); } else if (match_token(parser, TOKEN_RETURN)) { stmt = parse_return_statement(parser); } else if (match_token(parser, TOKEN_BREAK)) { stmt = parse_break_statement(parser); } else if (match_token(parser, TOKEN_CONTINUE)) { stmt = parse_continue_statement(parser); } else if (match_token(parser, TOKEN_IMPORT)) { stmt = parse_import_statement(parser); } else if (match_token(parser, TOKEN_TRY)) { stmt = parse_try_catch_statement(parser); } else if (match_token(parser, TOKEN_THROW)) { stmt = parse_throw_statement(parser); } else { // 表达式语句 stmt = parse_expression_statement(parser); if (match_token(parser, TOKEN_SEMICOLON)) { consume_token(parser); // 消费分号 } } // 如果有注解，将注解附加到语句上 if (annotations->children_count > 0 && stmt != NULL) { // 将注解作为语句的第一个子节点 // 先保存原有的子节点 int original_count = stmt->children_count; ASTNode** original_children = malloc(sizeof(ASTNode*) * original_count); for (int i = 0; i < original_count; i++) { original_children[i] = stmt->children[i]; } // 清空子节点数组 stmt->children_count = 0; // 添加注解作为第一个子节点 add_child(stmt, annotations); // 重新添加原有的子节点 for (int i = 0; i < original_count; i++) { add_child(stmt, original_children[i]); } // 释放临时数组 free(original_children); } else { // 如果没有注解，释放annotations节点 free(annotations); } return stmt; } ASTNode* parse_throw_statement(Parser* parser) { ASTNode* node = create_node(NODE_THROW_STMT); set_node_position(node, parser->lexer->line, parser->lexer->column); consume_token(parser); // 解析throw后面的表达式 ASTNode* expr = parse_expression(parser); add_child(node, expr); // 可选的分号 if (match_token(parser, TOKEN_SEMICOLON)) consume_token(parser); return node; } // 解析表达式（处理逻辑运算符） // 获取运算符的优先级 int get_precedence(TokenType type) { switch (type) { case TOKEN_EQ: return PREC_ASSIGNMENT; case TOKEN_PLUS_ASSIGN: case TOKEN_MINUS_ASSIGN: case TOKEN_MUL_ASSIGN: case TOKEN_DIV_ASSIGN: case TOKEN_MOD_ASSIGN: case TOKEN_BITAND_ASSIGN: case TOKEN_BITOR_ASSIGN: case TOKEN_BITXOR_ASSIGN: case TOKEN_SHL_ASSIGN: case TOKEN_SHR_ASSIGN: return PREC_ASSIGNMENT; case TOKEN_QUESTION: return PREC_TERNARY; case TOKEN_OR: return PREC_OR; case TOKEN_AND: return PREC_AND; case TOKEN_EQ_EQ: case TOKEN_NE: return PREC_EQUALITY; case TOKEN_LT: case TOKEN_GT: case TOKEN_LE: case TOKEN_GE: return PREC_COMPARISON; case TOKEN_BITAND: case TOKEN_BITOR: case TOKEN_BITXOR: return PREC_BITWISE; case TOKEN_SHL: case TOKEN_SHR: return PREC_SHIFT; case TOKEN_PLUS: case TOKEN_MINUS: return PREC_TERM; case TOKEN_STAR: case TOKEN_SLASH: case TOKEN_MOD: return PREC_FACTOR; case TOKEN_LPAREN: case TOKEN_DOT: case TOKEN_LBRACKET: return PREC_CALL; // 函数调用优先级 case TOKEN_AS: return PREC_CAST; // 类型转换优先级 default: return PREC_NONE; } } // 解析一元表达式 ASTNode* parse_unary(Parser* parser) { // 处理前缀运算符（一元运算符） if (match_token(parser, TOKEN_MINUS) || match_token(parser, TOKEN_NOT) || match_token(parser, TOKEN_BANG) || match_token(parser, TOKEN_PLUS_PLUS) || match_token(parser, TOKEN_MINUS_MINUS) || match_token(parser, TOKEN_TILDE)) { Token op = consume_token(parser); ASTNode* operand = parse_unary(parser); // 递归处理嵌套的一元表达式 ASTNode* unary = create_node(NODE_UNARY_EXPR); set_node_position(unary, op.line, op.column); unary->value = strdup(op.value); add_child(unary, operand); return unary; } return parse_primary(parser); } // 解析表达式 ASTNode* parse_expression(Parser* parser) { return parse_expression_with_precedence(parser, PREC_NONE); } // 根据优先级解析表达式 ASTNode* parse_expression_with_precedence(Parser* parser, int precedence) { ASTNode* left = parse_unary(parser); // 处理后缀表达式（自增、自减） while (match_token(parser, TOKEN_PLUS_PLUS) || match_token(parser, TOKEN_MINUS_MINUS)) { Token op = consume_token(parser); ASTNode* postfix = create_node(NODE_POSTFIX_EXPR); set_node_position(postfix, op.line, op.column); postfix->value = strdup(op.value); add_child(postfix, left); left = postfix; } while (precedence < get_precedence(parser->current_token.type)) { TokenType op_type = parser->current_token.type; Token op = consume_token(parser); // 处理类型转换 if (op_type == TOKEN_AS) { ASTNode* cast = create_node(NODE_CAST_EXPR); set_node_position(cast, op.line, op.column); add_child(cast, left); // 解析目标类型 Token type_token = consume_token(parser); ASTNode* type_node = create_node(NODE_TYPE_IDENTIFIER); set_node_position(type_node, type_token.line, type_token.column); type_node->value = strdup(type_token.value); add_child(cast, type_node); left = cast; continue; } // 处理三元运算符 if (op_type == TOKEN_QUESTION) { // 创建三元表达式节点 ASTNode* ternary = create_node(NODE_TERNARY_EXPR); set_node_position(ternary, op.line, op.column); ternary->op_type = OP_TERNARY; // 添加条件表达式 add_child(ternary, left); // 解析真值表达式 ASTNode* true_expr = parse_expression_with_precedence(parser, PREC_NONE); add_child(ternary, true_expr); // 解析冒号 expect_token(parser, TOKEN_COLON); // 解析假值表达式 ASTNode* false_expr = parse_expression_with_precedence(parser, PREC_TERNARY); add_child(ternary, false_expr); left = ternary; continue; } // 处理函数调用、成员访问和索引访问（从左到右结合） if (op_type == TOKEN_LPAREN || op_type == TOKEN_DOT || op_type == TOKEN_LBRACKET) { if (op_type == TOKEN_LPAREN) { ASTNode* call = create_node(NODE_CALL_EXPR); set_node_position(call, op.line, op.column); add_child(call, left); if (!match_token(parser, TOKEN_RPAREN)) { // 创建参数列表节点 ASTNode* params_node = create_node(NODE_PARAM_LIST); set_node_position(params_node, parser->lexer->line, parser->lexer->column); add_child(call, params_node); while (!match_token(parser, TOKEN_RPAREN)) { if (match_token(parser, TOKEN_IDENTIFIER)) { Token identifier = parser->current_token; consume_token(parser); // 检查是否有等号（命名参数） if (match_token(parser, TOKEN_EQ)) { consume_token(parser); ASTNode* named_arg = create_node(NODE_NAMED_ARG); set_node_position(named_arg, identifier.line, identifier.column); // 添加参数名节点 ASTNode* name_node = create_node(NODE_IDENTIFIER); name_node->value = strdup(identifier.value); set_node_position(name_node, identifier.line, identifier.column); add_child(named_arg, name_node); // 解析并添加参数值 ASTNode* value = parse_expression_with_precedence(parser, PREC_NONE); add_child(named_arg, value); add_child(params_node, named_arg); } else { // 不是命名参数，回退并按普通参数处理 parser->lexer->current_pos--; parser->lexer->column = parser->lexer->column - strlen(identifier.value); parser->current_token = identifier; ASTNode* arg = parse_expression_with_precedence(parser, PREC_NONE); add_child(params_node, arg); } } else { // 普通参数 ASTNode* arg = parse_expression_with_precedence(parser, PREC_NONE); add_child(params_node, arg); } if (match_token(parser, TOKEN_COMMA)) { consume_token(parser); } else { break; } } } expect_token(parser, TOKEN_RPAREN); left = call; } else if (op_type == TOKEN_DOT) { ASTNode* member = create_node(NODE_MEMBER_EXPR); set_node_position(member, op.line, op.column); add_child(member, left); Token identifier = expect_token(parser, TOKEN_IDENTIFIER); ASTNode* id_node = create_node(NODE_IDENTIFIER); set_node_position(id_node, identifier.line, identifier.column); id_node->value = strdup(identifier.value); add_child(member, id_node); left = member; } else { // TOKEN_LBRACKET ASTNode* index = create_node(NODE_INDEX_EXPR); set_node_position(index, op.line, op.column); add_child(index, left); ASTNode* expr = parse_expression_with_precedence(parser, PREC_NONE); add_child(index, expr); expect_token(parser, TOKEN_RBRACKET); left = index; } } // 处理二元运算符（从左到右结合） else { int new_precedence = get_precedence(op_type); // 对于相同优先级的运算符，增加一个微小的优先级来确保左结合性 ASTNode* right = parse_expression_with_precedence(parser, new_precedence + 1); // 创建二元表达式节点 ASTNode* binary = create_node(NODE_BINARY_EXPR); set_node_position(binary, op.line, op.column); // 设置操作符类型 switch (op_type) { // 算术运算符 case TOKEN_PLUS: binary->op_type = OP_ADD; break; case TOKEN_MINUS: binary->op_type = OP_SUB; break; case TOKEN_STAR: binary->op_type = OP_MUL; break; case TOKEN_SLASH: binary->op_type = OP_DIV; break; case TOKEN_MOD: binary->op_type = OP_MOD; break; // 逻辑运算符 case TOKEN_AND: binary->op_type = OP_AND; break; case TOKEN_OR: binary->op_type = OP_OR; break; // 比较运算符 case TOKEN_EQ_EQ: binary->op_type = OP_EQ; break; case TOKEN_NE: binary->op_type = OP_NE; break; case TOKEN_LT: binary->op_type = OP_LT; break; case TOKEN_GT: binary->op_type = OP_GT; break; case TOKEN_LE: binary->op_type = OP_LE; break; case TOKEN_GE: binary->op_type = OP_GE; break; // 位运算符 case TOKEN_BITAND: binary->op_type = OP_BITAND; break; case TOKEN_BITOR: binary->op_type = OP_BITOR; break; case TOKEN_BITXOR: binary->op_type = OP_BITXOR; break; case TOKEN_SHL: binary->op_type = OP_SHL; break; case TOKEN_SHR: binary->op_type = OP_SHR; break; // 赋值运算符 case TOKEN_EQ: binary->op_type = OP_ASSIGN; break; case TOKEN_PLUS_ASSIGN: binary->op_type = OP_PLUS_ASSIGN; break; case TOKEN_MINUS_ASSIGN: binary->op_type = OP_MINUS_ASSIGN; break; case TOKEN_MUL_ASSIGN: binary->op_type = OP_MUL_ASSIGN; break; case TOKEN_DIV_ASSIGN: binary->op_type = OP_DIV_ASSIGN; break; case TOKEN_MOD_ASSIGN: binary->op_type = OP_MOD_ASSIGN; break; case TOKEN_BITAND_ASSIGN: binary->op_type = OP_BITAND_ASSIGN; break; case TOKEN_BITOR_ASSIGN: binary->op_type = OP_BITOR_ASSIGN; break; case TOKEN_BITXOR_ASSIGN: binary->op_type = OP_BITXOR_ASSIGN; break; case TOKEN_SHL_ASSIGN: binary->op_type = OP_SHL_ASSIGN; break; case TOKEN_SHR_ASSIGN: binary->op_type = OP_SHR_ASSIGN; break; default: parser_error_at_current(parser, "Unknown binary operator"); return NULL; } binary->value = strdup(op.value); add_child(binary, left); add_child(binary, right); left = binary; } } if (match_token(parser, TOKEN_SEMICOLON)) consume_token(parser); return left; } ASTNode* parse_primary(Parser* parser) { ASTNode *node = NULL; if (match_token(parser, TOKEN_INT_LITERAL)) { Token token = consume_token(parser); node = create_node(NODE_INT_LITERAL); set_node_position(node, token.line, token.column); node->value = strdup(token.value); } else if (match_token(parser, TOKEN_FLOAT_LITERAL)) { Token token = consume_token(parser); node = create_node(NODE_FLOAT_LITERAL); set_node_position(node, token.line, token.column); node->value = strdup(token.value); } else if (match_token(parser, TOKEN_STRING_LITERAL)) { Token token = consume_token(parser); node = create_node(NODE_STRING_LITERAL); set_node_position(node, token.line, token.column); node->value = strdup(token.value); } else if (match_token(parser, TOKEN_IDENTIFIER)) { Token token = consume_token(parser); node = create_node(NODE_IDENTIFIER); set_node_position(node, token.line, token.column); node->value = strdup(token.value); } else if (match_token(parser, TOKEN_TRUE) || match_token(parser, TOKEN_FALSE)) { Token token = consume_token(parser); node = create_node(NODE_BOOL_LITERAL); set_node_position(node, token.line, token.column); node->value = strdup(token.value); } else if (match_token(parser, TOKEN_LPAREN)) { consume_token(parser); ASTNode* expr = parse_expression(parser); expect_token(parser, TOKEN_RPAREN); return expr; } else if (match_token(parser, TOKEN_LBRACKET)) { return parse_array_literal(parser); } else if (match_token(parser, TOKEN_LBRACE)) { return parse_key_value_literal(parser); } else { char error_message[256]; snprintf(error_message, sizeof(error_message), "unexpected token '%s'", token_type_to_string(parser->current_token.type)); parser_error_at_current(parser, error_message); } return node; } // 解析程序 ASTNode* parse_program(Parser* parser) { ASTNode* program = create_node(NODE_PROGRAM); set_node_position(program, parser->lexer->line, parser->lexer->column); while (!match_token(parser, TOKEN_EOF)) { ASTNode *stmt = parse_statement(parser); if (stmt != NULL) { add_child(program, stmt); } } return program; }