JGZSunShineMod1.0.3
464 lines
14 KiB
C++
464 lines
14 KiB
C++
#pragma once
|
|
|
|
#include <vector>
|
|
#include <string>
|
|
#include <map>
|
|
#include <memory>
|
|
|
|
namespace oraset3 {
|
|
|
|
// Token类型
|
|
enum class TokenType {
|
|
// 关键字
|
|
VAR, LET, CONST, FUNC, STRUCT, INTERFACE, UNION, ENUM,
|
|
IF, ELSE, FOR, WHILE, RETURN, BREAK, CONTINUE,
|
|
IMPORT, EXPORT, TRUE, FALSE, NIL,
|
|
|
|
// 标识符和字面量
|
|
IDENTIFIER, INTEGER, FLOAT, STRING,
|
|
|
|
// 运算符
|
|
PLUS, MINUS, MUL, DIV, MOD,
|
|
EQ, NEQ, LT, GT, LE, GE,
|
|
AND, OR, NOT,
|
|
ASSIGN, COLON_ASSIGN, ADD_ASSIGN, SUB_ASSIGN, MUL_ASSIGN, DIV_ASSIGN,
|
|
SHL, SHR,
|
|
BIT_AND, BIT_OR, BIT_XOR, BIT_NOT, // 位操作符
|
|
POINTER, // * 用于指针声明和解引用
|
|
ADDRESS, // & 用于取地址
|
|
|
|
// 标点符号
|
|
LPAREN, RPAREN, LBRACE, RBRACE, LBRACKET, RBRACKET,
|
|
COMMA, SEMICOLON, COLON, DOUBLE_COLON, DOT,
|
|
|
|
// 特殊
|
|
END_OF_FILE, IMPORT_DIRECTIVE
|
|
};
|
|
|
|
// Token结构
|
|
struct Token {
|
|
TokenType type;
|
|
std::string value;
|
|
int line;
|
|
int column;
|
|
|
|
Token(TokenType t, const std::string& v, int l, int c)
|
|
: type(t), value(v), line(l), column(c) {}
|
|
};
|
|
|
|
// AST节点类型
|
|
enum class NodeType {
|
|
PROGRAM,
|
|
VAR_DECL,
|
|
FUNC_DECL,
|
|
STRUCT_DECL,
|
|
INTERFACE_DECL,
|
|
UNION_DECL, // 联合体声明
|
|
ENUM_DECL, // 枚举声明
|
|
IF_STMT,
|
|
FOR_STMT,
|
|
WHILE_STMT,
|
|
RETURN_STMT,
|
|
EXPR_STMT,
|
|
ASSIGN_EXPR,
|
|
BINARY_EXPR,
|
|
UNARY_EXPR,
|
|
CALL_EXPR,
|
|
INDEX_EXPR,
|
|
MEMBER_EXPR,
|
|
LITERAL_EXPR,
|
|
IDENTIFIER_EXPR,
|
|
STRUCT_INIT,
|
|
CAST_EXPR // 类型转换表达式
|
|
};
|
|
|
|
// AST节点基类
|
|
class ASTNode {
|
|
public:
|
|
virtual ~ASTNode() = default;
|
|
virtual NodeType getType() const = 0;
|
|
virtual void accept(class ASTVisitor& visitor) = 0;
|
|
};
|
|
|
|
// AST访问者模式
|
|
class ASTVisitor {
|
|
public:
|
|
virtual ~ASTVisitor() = default;
|
|
virtual void visit(class ProgramNode& node) = 0;
|
|
virtual void visit(class VarDeclNode& node) = 0;
|
|
virtual void visit(class FuncDeclNode& node) = 0;
|
|
virtual void visit(class StructDeclNode& node) = 0;
|
|
virtual void visit(class InterfaceDeclNode& node) = 0;
|
|
virtual void visit(class UnionDeclNode& node) = 0;
|
|
virtual void visit(class EnumDeclNode& node) = 0;
|
|
virtual void visit(class IfStmtNode& node) = 0;
|
|
virtual void visit(class ForStmtNode& node) = 0;
|
|
virtual void visit(class WhileStmtNode& node) = 0;
|
|
virtual void visit(class ReturnStmtNode& node) = 0;
|
|
virtual void visit(class ExprStmtNode& node) = 0;
|
|
virtual void visit(class AssignExprNode& node) = 0;
|
|
virtual void visit(class BinaryExprNode& node) = 0;
|
|
virtual void visit(class UnaryExprNode& node) = 0;
|
|
virtual void visit(class CallExprNode& node) = 0;
|
|
virtual void visit(class IndexExprNode& node) = 0;
|
|
virtual void visit(class MemberExprNode& node) = 0;
|
|
virtual void visit(class LiteralExprNode& node) = 0;
|
|
virtual void visit(class IdentifierExprNode& node) = 0;
|
|
virtual void visit(class StructInitNode& node) = 0;
|
|
virtual void visit(class CastExprNode& node) = 0;
|
|
};
|
|
|
|
// 具体AST节点类型定义
|
|
class ProgramNode : public ASTNode {
|
|
public:
|
|
std::vector<std::unique_ptr<ASTNode>> declarations;
|
|
|
|
NodeType getType() const override { return NodeType::PROGRAM; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class VarDeclNode : public ASTNode {
|
|
public:
|
|
std::string name;
|
|
std::string type;
|
|
std::unique_ptr<ASTNode> initializer;
|
|
|
|
NodeType getType() const override { return NodeType::VAR_DECL; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class FuncDeclNode : public ASTNode {
|
|
public:
|
|
std::string name;
|
|
std::vector<std::pair<std::string, std::string>> params;
|
|
std::string returnType;
|
|
std::vector<std::unique_ptr<ASTNode>> body;
|
|
|
|
NodeType getType() const override { return NodeType::FUNC_DECL; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class StructDeclNode : public ASTNode {
|
|
public:
|
|
std::string name;
|
|
std::vector<std::pair<std::string, std::string>> fields;
|
|
|
|
NodeType getType() const override { return NodeType::STRUCT_DECL; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class InterfaceDeclNode : public ASTNode {
|
|
public:
|
|
std::string name;
|
|
std::vector<std::pair<std::string, std::string>> methods;
|
|
|
|
NodeType getType() const override { return NodeType::INTERFACE_DECL; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class IfStmtNode : public ASTNode {
|
|
public:
|
|
std::unique_ptr<ASTNode> condition;
|
|
std::vector<std::unique_ptr<ASTNode>> thenBranch;
|
|
std::vector<std::unique_ptr<ASTNode>> elseBranch;
|
|
|
|
NodeType getType() const override { return NodeType::IF_STMT; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class ForStmtNode : public ASTNode {
|
|
public:
|
|
std::unique_ptr<ASTNode> init;
|
|
std::unique_ptr<ASTNode> condition;
|
|
std::unique_ptr<ASTNode> update;
|
|
std::vector<std::unique_ptr<ASTNode>> body;
|
|
|
|
NodeType getType() const override { return NodeType::FOR_STMT; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class WhileStmtNode : public ASTNode {
|
|
public:
|
|
std::unique_ptr<ASTNode> condition;
|
|
std::vector<std::unique_ptr<ASTNode>> body;
|
|
|
|
NodeType getType() const override { return NodeType::WHILE_STMT; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class ReturnStmtNode : public ASTNode {
|
|
public:
|
|
std::unique_ptr<ASTNode> expr;
|
|
|
|
NodeType getType() const override { return NodeType::RETURN_STMT; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class ExprStmtNode : public ASTNode {
|
|
public:
|
|
std::unique_ptr<ASTNode> expr;
|
|
|
|
NodeType getType() const override { return NodeType::EXPR_STMT; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class AssignExprNode : public ASTNode {
|
|
public:
|
|
std::unique_ptr<ASTNode> left;
|
|
std::unique_ptr<ASTNode> right;
|
|
std::string op;
|
|
|
|
NodeType getType() const override { return NodeType::ASSIGN_EXPR; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class BinaryExprNode : public ASTNode {
|
|
public:
|
|
std::unique_ptr<ASTNode> left;
|
|
std::unique_ptr<ASTNode> right;
|
|
std::string op;
|
|
|
|
NodeType getType() const override { return NodeType::BINARY_EXPR; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class UnaryExprNode : public ASTNode {
|
|
public:
|
|
std::unique_ptr<ASTNode> operand;
|
|
std::string op;
|
|
|
|
NodeType getType() const override { return NodeType::UNARY_EXPR; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class CallExprNode : public ASTNode {
|
|
public:
|
|
std::unique_ptr<ASTNode> callee;
|
|
std::vector<std::unique_ptr<ASTNode>> args;
|
|
|
|
NodeType getType() const override { return NodeType::CALL_EXPR; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class IndexExprNode : public ASTNode {
|
|
public:
|
|
std::unique_ptr<ASTNode> base;
|
|
std::unique_ptr<ASTNode> index;
|
|
|
|
NodeType getType() const override { return NodeType::INDEX_EXPR; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class MemberExprNode : public ASTNode {
|
|
public:
|
|
std::unique_ptr<ASTNode> object;
|
|
std::string property;
|
|
std::string op;
|
|
|
|
NodeType getType() const override { return NodeType::MEMBER_EXPR; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class StructInitNode : public ASTNode {
|
|
public:
|
|
std::string typeName;
|
|
std::vector<std::pair<std::string, std::unique_ptr<ASTNode>>> fields;
|
|
|
|
NodeType getType() const override { return NodeType::STRUCT_INIT; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class LiteralExprNode : public ASTNode {
|
|
public:
|
|
std::string value;
|
|
std::string type;
|
|
|
|
NodeType getType() const override { return NodeType::LITERAL_EXPR; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
class IdentifierExprNode : public ASTNode {
|
|
public:
|
|
std::string name;
|
|
|
|
NodeType getType() const override { return NodeType::IDENTIFIER_EXPR; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
// 联合体声明节点
|
|
class UnionDeclNode : public ASTNode {
|
|
public:
|
|
std::string name;
|
|
std::vector<std::pair<std::string, std::string>> fields;
|
|
|
|
NodeType getType() const override { return NodeType::UNION_DECL; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
// 枚举声明节点
|
|
class EnumDeclNode : public ASTNode {
|
|
public:
|
|
std::string name;
|
|
std::vector<std::pair<std::string, std::string>> values; // name -> value
|
|
|
|
NodeType getType() const override { return NodeType::ENUM_DECL; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
// 类型转换表达式节点
|
|
class CastExprNode : public ASTNode {
|
|
public:
|
|
std::string targetType;
|
|
std::unique_ptr<ASTNode> expr;
|
|
|
|
NodeType getType() const override { return NodeType::CAST_EXPR; }
|
|
void accept(ASTVisitor& visitor) override { visitor.visit(*this); }
|
|
};
|
|
|
|
// 词法分析器
|
|
class Lexer {
|
|
public:
|
|
Lexer(const std::string& source);
|
|
std::unique_ptr<Token> nextToken();
|
|
|
|
private:
|
|
std::string source;
|
|
size_t pos;
|
|
int line;
|
|
int column;
|
|
char currentChar();
|
|
void advance();
|
|
void skipWhitespace();
|
|
std::string readIdentifier();
|
|
std::string readNumber();
|
|
std::string readString(char quote);
|
|
};
|
|
|
|
// 语法分析器
|
|
class Parser {
|
|
public:
|
|
Parser(std::vector<std::unique_ptr<Token>> tokens);
|
|
std::unique_ptr<ProgramNode> parse();
|
|
|
|
private:
|
|
std::vector<std::unique_ptr<Token>> tokens;
|
|
size_t pos;
|
|
|
|
Token* currentToken();
|
|
Token* peekToken();
|
|
void advance();
|
|
bool match(TokenType type);
|
|
bool consume(TokenType type);
|
|
|
|
std::unique_ptr<ASTNode> parseDeclaration();
|
|
std::unique_ptr<ASTNode> parseVarDecl();
|
|
std::unique_ptr<ASTNode> parseFuncDecl();
|
|
std::unique_ptr<ASTNode> parseStructDecl();
|
|
std::unique_ptr<ASTNode> parseInterfaceDecl();
|
|
std::unique_ptr<ASTNode> parseUnionDecl();
|
|
std::unique_ptr<ASTNode> parseEnumDecl();
|
|
std::unique_ptr<ASTNode> parseStatement();
|
|
std::unique_ptr<ASTNode> parseIfStmt();
|
|
std::unique_ptr<ASTNode> parseForStmt();
|
|
std::unique_ptr<ASTNode> parseWhileStmt();
|
|
std::unique_ptr<ASTNode> parseReturnStmt();
|
|
std::unique_ptr<ASTNode> parseBlock();
|
|
std::unique_ptr<ASTNode> parseExpression();
|
|
std::unique_ptr<ASTNode> parseAssignment();
|
|
std::unique_ptr<ASTNode> parseLogicalOr();
|
|
std::unique_ptr<ASTNode> parseLogicalAnd();
|
|
std::unique_ptr<ASTNode> parseEquality();
|
|
std::unique_ptr<ASTNode> parseComparison();
|
|
std::unique_ptr<ASTNode> parseShift();
|
|
std::unique_ptr<ASTNode> parseAdditive();
|
|
std::unique_ptr<ASTNode> parseMultiplicative();
|
|
std::unique_ptr<ASTNode> parseUnary();
|
|
std::unique_ptr<ASTNode> parsePostfix();
|
|
std::unique_ptr<ASTNode> parsePrimary();
|
|
};
|
|
|
|
// 语义分析器
|
|
class SemanticAnalyzer : public ASTVisitor {
|
|
public:
|
|
SemanticAnalyzer(bool sysui = false) : sysuiImported(sysui) {}
|
|
void analyze(ProgramNode& program);
|
|
bool hasErrors() const { return !errors.empty(); }
|
|
const std::vector<std::string>& getErrors() const { return errors; }
|
|
|
|
private:
|
|
std::vector<std::string> errors;
|
|
std::map<std::string, std::string> symbolTable;
|
|
bool sysuiImported;
|
|
|
|
void visit(ProgramNode& node) override;
|
|
void visit(VarDeclNode& node) override;
|
|
void visit(FuncDeclNode& node) override;
|
|
void visit(StructDeclNode& node) override;
|
|
void visit(InterfaceDeclNode& node) override;
|
|
void visit(UnionDeclNode& node) override;
|
|
void visit(EnumDeclNode& node) override;
|
|
void visit(CastExprNode& node) override;
|
|
void visit(IfStmtNode& node) override;
|
|
void visit(ForStmtNode& node) override;
|
|
void visit(WhileStmtNode& node) override;
|
|
void visit(ReturnStmtNode& node) override;
|
|
void visit(ExprStmtNode& node) override;
|
|
void visit(AssignExprNode& node) override;
|
|
void visit(BinaryExprNode& node) override;
|
|
void visit(UnaryExprNode& node) override;
|
|
void visit(CallExprNode& node) override;
|
|
void visit(IndexExprNode& node) override;
|
|
void visit(MemberExprNode& node) override;
|
|
void visit(LiteralExprNode& node) override;
|
|
void visit(IdentifierExprNode& node) override;
|
|
void visit(StructInitNode& node) override;
|
|
};
|
|
|
|
// 代码生成器
|
|
class CodeGenerator : public ASTVisitor {
|
|
public:
|
|
CodeGenerator(bool sysui = false) : sysuiImported(sysui) {}
|
|
std::string generate(ProgramNode& program);
|
|
|
|
private:
|
|
std::string code;
|
|
int indent;
|
|
bool sysuiImported;
|
|
|
|
void emit(const std::string& str);
|
|
void emitLine(const std::string& str);
|
|
void indentUp();
|
|
void indentDown();
|
|
|
|
void visit(ProgramNode& node) override;
|
|
void visit(VarDeclNode& node) override;
|
|
void visit(FuncDeclNode& node) override;
|
|
void visit(StructDeclNode& node) override;
|
|
void visit(InterfaceDeclNode& node) override;
|
|
void visit(UnionDeclNode& node) override;
|
|
void visit(EnumDeclNode& node) override;
|
|
void visit(CastExprNode& node) override;
|
|
void visit(IfStmtNode& node) override;
|
|
void visit(ForStmtNode& node) override;
|
|
void visit(WhileStmtNode& node) override;
|
|
void visit(ReturnStmtNode& node) override;
|
|
void visit(ExprStmtNode& node) override;
|
|
void visit(AssignExprNode& node) override;
|
|
void visit(BinaryExprNode& node) override;
|
|
void visit(UnaryExprNode& node) override;
|
|
void visit(CallExprNode& node) override;
|
|
void visit(IndexExprNode& node) override;
|
|
void visit(MemberExprNode& node) override;
|
|
void visit(LiteralExprNode& node) override;
|
|
void visit(IdentifierExprNode& node) override;
|
|
void visit(StructInitNode& node) override;
|
|
};
|
|
|
|
// 编译器类
|
|
class Compiler {
|
|
public:
|
|
std::string compile(const std::string& source);
|
|
};
|
|
|
|
} // namespace oraset3
|