基于C语言生成parser tree

末蓝、 2024-04-07 15:35 27阅读 0赞

## 通过 C 语言生成 parser tree ##

## 1 序言 ##

### 1.1 文件说明 ###

`src/ast.hpp` 和 `src/ast.cpp` 为对 AST 的实现。在 `ast.hpp` 中为对各个节点的定义，在 `ast.cpp` 中为用于在命令行中打印当前 AST 的函数 `void PrintASTNode(const ASTNode *curNode)` 和接口 `void PrintAST(const ASTProgram *program)`。

### 1.2 组员分工 ###

原本规划时将整个任务分为五个部分：词法分析、语法分析、语义分析、中间代码和目标代码生成。但在实际的代码过程中，发现可以通过 LLVM 实现 IR 到目标代码的转换，因此调整为“词法分析、语法分析、语义分析、中间代码”四部分。并且，原先计划的是通过 C 语言生成 parser tree 而非 AST，而 LLVM 的官方文档是在使用 C++ 文法的抽象语法树的基础上生成的中间代码的，因此额外添加了 AST 相关的类以及从 parser tree 到 AST 的转换，用于后续的中间代码生成。

最终的分工如下：

*  包云泰：通过词法分析和语法分析生成符合 C Minus 语言语法的 Parser Tree，并根据该 Parser Tree进行语义分析。
 *  罗志凡：设计 AST ，并将上述 parser tree 转换为 AST 为中间代码生成提供接口。
 *  杨静远：根据 AST 生成 IR 并通过 LLVM 生成目标代码。

## 2 抽象语法树 ##

由于最初的规划中没有考虑到要使用 LLVM，yacc 程序运行的结果是构造一个 Parser Tree，并且语法分析和语义分析都是基于 Parser Tree 完成的。而 LLVM 的文档中均是对 AST 进行处理，并且使用的语言为 C++ 而非之前计划所用的 C，因此我们小组决定将 Parser Tree 转换为 AST 来为后续的中间代码生成和目标代码生成提供安全可靠的接口。

### 2.1 AST 的设计 ###

AST 的设计坚持两个原则：

1.  保证对原有语法规则的保留；
2.  一切从简，并尽可能减少树的高度，以便于后续的调用。

最终，我们设计了如下图所示的抽象语法树，具体的类定义位于文件 `src/ast.hpp` 中。

**基类 `Class ASTNode`**

首先是设计了一个基类 `ASTNode`，用于存储各种节点都有的行、列信息，并且保存当前节点的类型。其中行列信息未赋值时初始化为 -1，节点类型未赋值时初始化为标识 `ASTNode` 节点。用户只能通过函数 `void SetCoordinate(int lineno, int column);` 和 `void SetNodeType(ASTNodeType setNodeType);` 修改节点的基本信息，通过对应的 `get` 函数对成员变量进行访问。

class ASTNode
    {
        int lineno, column;
        ASTNodeType nodeType;
    
    public:
        ASTNode(int lineno = -1, int column = -1, ASTNodeType nodeType = ASTNODE)
            : lineno(lineno), column(column), nodeType(nodeType) {}
        virtual ~ASTNode() {}
        void SetCoordinate(int lineno, int column)
        {
            ASTNode::lineno = lineno;
            ASTNode::column = column;
        }
    
        int GetLineno() const { return lineno; }
        int GetColumn() const { return column; }
        void SetNodeType(ASTNodeType setNodeType) { nodeType = setNodeType; }
        ASTNodeType GetNodeType() const { return nodeType; }
    };

**派生类 `class ASTProgram : public ASTNode`**

程序由声明列表组成，声明可以是函数声明或变量声明，并且对声明顺序没有限制。由于函数声明和变量声明的类不同，因此通过基类指针来访问派生类内容。

class ASTProgram : public ASTNode
    {
        vector<ASTNode *> declList;
    
    public:
        ASTProgram() { SetNodeType(ASTPROGRAM); }
        ~ASTProgram() {}
    
        void AddDecl(ASTNode *decl) { declList.push_back(decl); }
        const vector<ASTNode *> &GetDeclList() const { return declList; }
    };

**派生类 `class ASTVarDecl : public ASTNode`**

变量声明，要么声明一个简单的整数类型变量，要么声明一个类型为整数或浮点数的数组变量。通过枚举变量 `typeSpec` 标识变量的数据类型，通过字符串变量 `id` 保存变量名，布尔变量 `isArray` 用于判断是否为数组，整型变量 `arrayLength` 用于记录数组长度。因为全局变量和局部变量存储数据的区域不同，额外添加布尔变量 `isGlobal` 用于标识当前变量是否为全局变量，默认为全局变量。

class ASTVarDecl : public ASTNode
    {
        ASTTypeSpec typeSpec; // int or real
        string id;
        bool isGlobal;
        bool isArray;
        int arrayLength;
    
    public:
        ASTVarDecl(ASTTypeSpec typeSpec, string id)
            : typeSpec(typeSpec), id(id), isGlobal(true), isArray(false) { SetNodeType(ASTVARDECL); }
    
        ASTVarDecl(ASTTypeSpec typeSpec, string id, int arrayLength)
            : typeSpec(typeSpec), id(id), isGlobal(true), isArray(true), arrayLength(arrayLength) { SetNodeType(ASTVARDECL); }
    
        ~ASTVarDecl(){};
    
        void SetAsLocal(){isGlobal = false};
    
        ASTTypeSpec GetTypeSpec() const { return typeSpec; }
        const string GetId() const { return id; }
        bool IsGlobal() const { return isGlobal; }
        bool IsArray() const { return isArray; }
        int GetArrayLength() const { return arrayLength; }
    };

**派生类 `class ASTFunDecl : public ASTNode`**

函数声明由返回类型、函数名、参数列表、函数体四个部分组成。由枚举变量 `typeSpec` 标识函数返回数据类型，通过字符串变量 `id` 保存函数名，布尔变量 `haveParam` 用于判断是否需要传入参数，向量 `paramList` 保存参数信息，类指针 `compoundStmt` 指向函数体。

class ASTFunDecl : public ASTNode
    {
        ASTTypeSpec typeSpec;
        string id;
        bool haveParam; // Is there an param.
        vector<ASTParam *> paramList;
        ASTCompoundStmt *compoundStmt;
    
    public:
        ASTFunDecl(ASTTypeSpec typeSpec, string id, bool haveParam = false)
            : typeSpec(typeSpec), id(id), haveParam(haveParam)
        {
            compoundStmt = NULL;
            SetNodeType(ASTFUNDECL);
        }
    
        ~ASTFunDecl() {}
    
        void AddParam(ASTParam *param)
        {
            if (!haveParam)
                haveParam = true;
            paramList.push_back(param);
        }
    
        void AddCompoundStmt(ASTCompoundStmt *compoundStmt) { ASTFunDecl::compoundStmt = compoundStmt; };
    
        ASTTypeSpec GetTypeSpec() const { return typeSpec; }
        const string GetId() const { return id; }
        bool HaveParam() const { return haveParam; }
        const vector<ASTParam *> &GetParamList() const { return paramList; }
        const ASTCompoundStmt *GetCompoundStmt() const { return compoundStmt; }
    };

**派生类 `class ASTParam : public ASTNode`**

函数的参数要么是 `void`（即没有参数），要么是表示函数参数的列表。带有中括号的参数是数组参数，其大小可以变化。简单的整数参数按值传递，数组参数通过引用（即作为指针）传递，并且在调用期间必须与数组变量匹配。

枚举变量 `typeSpec` 标识参数的数据类型，通过字符串变量 `id` 保存参数名，布尔变量 `isArray` 用于判断是否为数组参数。

class ASTParam : public ASTNode
    {
        ASTTypeSpec typeSpec;
        string id;
        bool isArray;
    
    public:
        ASTParam(ASTTypeSpec typeSpec, string id, bool isArray = false)
            : typeSpec(typeSpec), id(id), isArray(isArray) { SetNodeType(ASTPARAM); }
    
        ~ASTParam(){};
    
        ASTTypeSpec GetTypeSpec() const { return typeSpec; }
        const string GetId() const { return id; }
        bool IsArray() const { return isArray; }
    };

**派生类 `class ASTCompoundStmt : public ASTNode`**

复合语句由被大括号围绕的一组声明和语句组成。向量 `declList` 保存指向局部变量声明语句的指针列表，向量 `stmtList` 保存指向语句的指针列表。由于不同语句的类型不同，因此使用基类指针访问派生类。复合语句中的变量声明均为局部变量，且局部变量也只能在复合语句中声明，因此在添加变量声明节点时，将变量设置为局部变量。

class ASTCompoundStmt : public ASTNode
    {
        vector<ASTVarDecl *> declList;
        vector<ASTNode *> stmtList;
    
    public:
        ASTCompoundStmt() { SetNodeType(ASTCOMPOUNDSTMT); }
        ~ASTCompoundStmt() {}
    
        void AddDecl(ASTVarDecl *decl)
        {
            decl->SetAsLocal();
            declList.push_back(decl);
        };
        void AddStmt(ASTNode *stmt) { stmtList.push_back(stmt); };
        const vector<ASTVarDecl *> &GetDeclList() const { return declList; }
        const vector<ASTNode *> &GetStmtList() const { return stmtList; }
    };

**派生类 `class ASTExpr : public ASTNode`**

表达式可以是一个赋值语句，即变量引用后跟一个赋值符号（等号）和一个表达式，或者只是一个简单的表达式。通过布尔变量 `isAssignStmt` 判断该语句是否为赋值语句，如果是赋值语句，则 `var` 指向被引用的变量，`expr` 指向表达式，`simpleExpr` 为 `NULL`；否则该语句为简单的表达式，`var, expr` 为 `NULL`，`simpleExpr` 指向该简单的表达式。

class ASTExpr : public ASTNode
    {
        bool isAssignStmt;
        ASTVar *var;
        ASTExpr *expr;
        ASTSimpleExpr *simpleExpr;
    
    public:
        ASTExpr(ASTSimpleExpr *simpleExpr)
            : isAssignStmt(false), var(NULL), expr(NULL), simpleExpr(simpleExpr) { SetNodeType(ASTEXPR); }
    
        ASTExpr(ASTVar *var, ASTExpr *expr)
            : isAssignStmt(true), var(var), expr(expr), simpleExpr(NULL) { SetNodeType(ASTEXPR); }
    
        ~ASTExpr() {}
    
        bool IsAssignStmt() const { return isAssignStmt; }
        const ASTVar *GetVar() const { return var; }
        const ASTExpr *GetExpr() const { return expr; }
        const ASTSimpleExpr *GetSimpleExpr() const { return simpleExpr; }
    };

**派生类 `class ASTSelectStmt : public ASTNode`**

`if` 语句分为三个部分：表达式，表达式为真（值不为0）时执行的语句，表达式为假（值为0）时执行的语句（可以不存在）。指针 `expr` 指向待求值的表达式，`trueStmt` 指向表达式为真时执行的语句。布尔变量 `haveElse` 标识表达式为假时执行的语句是否存在，若存在，则 `falseStmt` 指向该语句，否则为 `NULL`。

语句可以是复合语句（带有大括号）、表达式、`if` 语句、`while` 语句、`for` 语句或返回语句。

class ASTSelectStmt : public ASTNode
    {
        ASTExpr *expr;
        ASTNode *trueStmt;
        bool haveElse;
        ASTNode *falseStmt;
    
    public:
        ASTSelectStmt(ASTExpr *expr, ASTNode *trueStmt)
            : expr(expr), trueStmt(trueStmt), haveElse(false), falseStmt(NULL) { SetNodeType(ASTSELECTSTMT); }
        ASTSelectStmt(ASTExpr *expr, ASTNode *trueStmt, ASTNode *falseStmt)
            : expr(expr), trueStmt(trueStmt), haveElse(true), falseStmt(falseStmt) { SetNodeType(ASTSELECTSTMT); }
        ~ASTSelectStmt() {}
    
        const ASTExpr *GetExpr() const { return expr; }
        const ASTNode *GetTrueStmt() const { return trueStmt; }
        bool HaveElse() const { return haveElse; }
        const ASTNode *GetFalseStmt() const { return falseStmt; }
    };

**派生类 `class ASTWhileStmt : public ASTNode`**

`while` 语句通过重复计算表达式来执行，如果表达式计算结果不为 0，则执行语句，否则结束执行。指针 `expr` 指向待求值的表达式，`trueStmt` 指向表达式计算结果不为 0 时执行的语句。

class ASTWhileStmt : public ASTNode
    {
        ASTExpr *expr;
        ASTNode *stmt;
    
    public:
        ASTWhileStmt(ASTExpr *expr, ASTNode *stmt) : expr(expr), stmt(stmt) { SetNodeType(ASTWHILESTMT); }
        ~ASTWhileStmt() {}
    
        const ASTExpr *GetExpr() const { return expr; }
        const ASTNode *GetStmt() const { return stmt; }
    };

**派生类 `class ASTForStmt : public ASTNode`**

`for` 语句由 4 个部分组成：赋值语句，表达式，赋值语句，循环执行的语句块。一般情况下，第一个赋值语句用于初始化的循环变量；表达式与循环变量相关的表达式；第二个赋值语句用于循环变量的增量计算。两条赋值语句均可以为空。

布尔变量 `haveForParam1` 和 `haveForParam3` 分别标识两条赋值语句是否存在，若为真，则 `var1` 和 `Var3` 分别指向引用的变量，`expr1` 和 `expr3` 分别指向用于赋值的表达式；若不为真，则 `var1`, `Var3`, `expr1` 和 `expr3` 均为 `NULL`。指针 `expr2` 指向控制循环的表达式，`stmt` 指向表达式计算结果不为 0 时执行的语句。

class ASTForStmt : public ASTNode
    {
        bool haveForParam1; // Is there an For_param1. false by default.
        ASTVar *var1;
        ASTExpr *expr1;
    
        ASTExpr *expr2;
    
        bool haveForParam3; // Is there an For_param3. false by default.
        ASTVar *var3;
        ASTExpr *expr3;
    
        ASTNode *stmt;
    
    public:
        ASTForStmt(ASTExpr *expr2, ASTNode *stmt)
            : haveForParam1(false), var1(NULL), expr1(NULL), expr2(expr2),
              haveForParam3(false), var3(NULL), expr3(NULL), stmt(stmt) { SetNodeType(ASTFORSTMT); }
        ~ASTForStmt() {}
    
        void AddForParam1(ASTVar *var1, ASTExpr *expr1)
        {
            if (!haveForParam1)
            {
                haveForParam1 = true;
                ASTForStmt::var1 = var1;
                ASTForStmt::expr1 = expr1;
            }
        }
    
        void AddForParam3(ASTVar *var3, ASTExpr *expr3)
        {
            if (!haveForParam3)
            {
                haveForParam3 = true;
                ASTForStmt::var3 = var3;
                ASTForStmt::expr3 = expr3;
            }
        }
    
        bool HaveForParam1() const { return haveForParam1; }
        const ASTVar *GetVar1() const { return var1; }
        const ASTExpr *GetExpr1() const { return expr1; }
        const ASTExpr *GetExpr2() const { return expr2; }
        bool HaveForParam3() const { return haveForParam3; }
        const ASTVar *GetVar3() const { return var3; }
        const ASTExpr *GetExpr3() const { return expr3; }
        const ASTNode *GetStmt() const { return stmt; }
    };

**派生类 `class ASTReturnStmt : public ASTNode`**

`return` 语句可以返回一个值，也可以不返回。 未声明为 `void` 的函数必须返回值。 声明为 `void` 的函数不得返回值。布尔变量 `isVoid` 标识函数返回类型是否为 `void`，若为真，则 `expr` 赋值为 `NULL`，否则指向待计算的返回表达式。

`isVoid` 默认为真，需要通过函数 `AddExpr` 来添加返回值。

class ASTReturnStmt : public ASTNode
    {
        bool isVoid; // Whether the function type is void. True by default.
        ASTExpr *expr;
    
    public:
        ASTReturnStmt() : isVoid(true), expr(NULL) { SetNodeType(ASTRETURNSTMT); }
        ~ASTReturnStmt() {}
    
        void AddExpr(ASTExpr *expr)
        {
            if (isVoid)
                isVoid = false;
            ASTReturnStmt::expr = expr;
        }
    
        bool IsVoid() const { return isVoid; }
        const ASTExpr *GetExpr() const { return expr; }
    };

**派生类 `class ASTVar : public ASTNode`**

`var` 可以是简单的变量，也可以是通过下标索引的数组中的元素。 与 C 不同的是，负数作为下标会导致程序停止。通过字符串变量 `id` 保存变量名，布尔变量 `haveSubscript` 用于判断是否为数组中的元素，若为真，则指针 `subscript` 指向用于计算下标的表达式，否则 `subscript` 为 `NULL`。

class ASTVar : public ASTNode
    {
        string id;
        bool haveSubscript;
        ASTExpr *subscript;
    
    public:
        ASTVar(string id) : id(id), haveSubscript(false), subscript(NULL) { SetNodeType(ASTVAR); }
        ASTVar(string id, ASTExpr *subscript) : id(id), haveSubscript(true), subscript(subscript) { SetNodeType(ASTVAR); }
    
        ~ASTVar() {}
    
        const string GetId() const { return id; }
        bool HaveSubscript() const { return haveSubscript; }
        const ASTExpr *GetSubscript() const { return subscript; }
    };

**派生类 `class ASTSimpleExpr : public ASTNode`**

简单的表达式用于表示关系运算。如果它不包含关系运算符，那么这个简单表达式的值就是作为它子项的加法表达式的值；否则其值为关系运算的计算结果，若结果为真，则值为 1，结果为假，则值为 0。

指针 `leftAddExpr` 指向关系运算符左边的加法表达式，布尔变量 `haveRightAddExpr` 用于判断关系运算是否存在。若存在，则枚举变量 `relOp` 标识关系运算类型，指针 `rightAddExpr` 指向关系运算符右边的加法表达式；若不存在，则 `rightAddExpr` 为 `NULL`。

class ASTSimpleExpr : public ASTNode
    {
        ASTAddExpr *leftAddExpr;
        bool haveRightAddExpr;
        ASTRelOp relOp;
        ASTAddExpr *rightAddExpr;
    
    public:
        ASTSimpleExpr(ASTAddExpr *addExpr) : leftAddExpr(addExpr), haveRightAddExpr(false)
        {
            rightAddExpr = NULL;
            SetNodeType(ASTSIMPLEEXPR);
        }
        ASTSimpleExpr(ASTAddExpr *leftAddExpr, ASTRelOp relOp, ASTAddExpr *rightAddExpr)
            : leftAddExpr(leftAddExpr), haveRightAddExpr(true), relOp(relOp), rightAddExpr(rightAddExpr) { SetNodeType(ASTSIMPLEEXPR); }
    
        ~ASTSimpleExpr() {}
    
        const ASTAddExpr *GetLeftAddExpr() const { return leftAddExpr; }
        bool HaveRightAddExpr() const { return haveRightAddExpr; }
        ASTRelOp GetRelOp() const { return relOp; }
        const ASTAddExpr *GetRightAddExpr() const { return rightAddExpr; }
    };

**派生类 `class ASTAddExpr : public ASTNode`**

加法表达式用于表示加法运算。如果它不包含加法运算符，那么这个简单表达式的值就是作为它子项的乘法表达式的值，否则其值为加法运算的计算结果。

指针 `firstTerm` 指向第一个乘法表达式，布尔变量 `areMultipleTerms` 用于判断是否存在多组加法运算，若存在，则向量 `addOpList` 和 `termList` 分别记录对应的加法运算符列表和乘法表达式指针列表。

class ASTAddExpr : public ASTNode
    {
        ASTTerm *firstTerm;
        bool areMultipleTerms; 
        vector<ASTAddOp> addOpList;
        vector<ASTTerm *> termList;
    
    public:
        ASTAddExpr(ASTTerm *firstTerm) : firstTerm(firstTerm), areMultipleTerms(false) { SetNodeType(ASTADDEXPR); }
        ~ASTAddExpr() {}
    
        void AddTerm(ASTAddOp addOp, ASTTerm *term)
        {
            if (!areMultipleTerms)
                areMultipleTerms = true;
            addOpList.push_back(addOp);
            termList.push_back(term);
        }
    
        const ASTTerm *GetFirstTerm() const { return firstTerm; }
        bool AreMultipleTerms() const { return areMultipleTerms; }
        const vector<ASTAddOp> &GetAddOpList() const { return addOpList; }
        const vector<ASTTerm *> &GetTermList() const { return termList; }
    };

**派生类 `class ASTTerm : public ASTNode`**

`Term` 用于表示乘法运算。如果它不包含乘法运算符，那么这个简单表达式的值就是作为它子项的因子（ `factor` ）的值，否则其值为乘法运算的计算结果。

指针 `firstFactor` 指向第一个乘法表达式，布尔变量 `areMultipleFactors` 用于判断是否存在多组加法运算，若存在，则向量 `mulOpList` 和 `factorList` 分别记录对应的乘法运算符列表和指向因子的指针列表。

class ASTTerm : public ASTNode
    {
    
        ASTFactor *firstFactor;
        bool areMultipleFactors; // Are there multiple factors? By default it's false.
        vector<ASTMulOp> mulOpList;
        vector<ASTFactor *> factorList;
    
    public:
        ASTTerm(ASTFactor *firstFactor) : firstFactor(firstFactor), areMultipleFactors(false) { SetNodeType(ASTTERM); }
        ~ASTTerm() {}
    
        void AddFactor(ASTMulOp mulOp, ASTFactor *factor)
        {
            if (!areMultipleFactors)
                areMultipleFactors = true;
            mulOpList.push_back(mulOp);
            factorList.push_back(factor);
        }
    
        const ASTFactor *GetFirstFactor() const { return firstFactor; }
        bool AreMultipleFactors() const { return areMultipleFactors; }
        const vector<ASTMulOp> &GetMulOpList() const { return mulOpList; }
        const vector<ASTFactor *> &GetFactorList() const { return factorList; }
    };

**派生类 `class ASTFactor : public ASTNode`**

因子可以是一个在括号中的表达式，一个变量， 一个函数调用或一个立即数。根据传入参数的不同调用不同的构造函数，进行对应的初始化。

class ASTFactor : public ASTNode
    {
        ASTExpr *expr;
        ASTVar *var;
        ASTCall *callExpr;
        bool isInt;
        bool isReal;
        int numInt;
        float numReal;
    
    public:
        ASTFactor(ASTExpr *expr) : expr(expr), var(NULL), callExpr(NULL), isInt(false), isReal(false) { SetNodeType(ASTFACTOR); }
        ASTFactor(ASTVar *var) : expr(NULL), var(var), callExpr(NULL), isInt(false), isReal(false) { SetNodeType(ASTFACTOR); }
        ASTFactor(ASTCall *callExpr) : expr(NULL), var(NULL), callExpr(callExpr), isInt(false), isReal(false) { SetNodeType(ASTFACTOR); }
        ASTFactor(int num) : expr(NULL), var(NULL), callExpr(NULL), isInt(true), isReal(false), numInt(num) { SetNodeType(ASTFACTOR); }
        ASTFactor(float num) : expr(NULL), var(NULL), callExpr(NULL), isInt(false), isReal(true)
        {
            numReal = num;
            SetNodeType(ASTFACTOR);
        }
    
        ~ASTFactor() {}
    
        const ASTExpr *GetExpr() const { return expr; }
        const ASTVar *GetVar() const { return var; }
        const ASTCall *GetCallExpr() const { return callExpr; }
        bool IsInt() const { return isInt; }
        int GetNumInt() const
        {
            if (isInt)
                return numInt;
        }
        bool IsReal() const
        {
            if (isReal)
                return isReal;
        }
        float GetNumReal() const { return numReal; }
    };

**派生类 `class ASTCall : public ASTNode`**

函数调用由一个 ID（函数的名称）和其参数组成。通过字符串变量 `id` 保存调用的函数名，向量 `argList` 保存参数列表。默认不需要传入参数，需要通过函数 `AddArg` 添加。

class ASTCall : public ASTNode
    {
        string id;
        vector<ASTExpr *> argList;
    
    public:
        ASTCall(string id) : id(id) { SetNodeType(ASTCALL); }
        ~ASTCall() {}
    
        void AddArg(ASTExpr *arg) { argList.push_back(arg); }
    
        const string GetId() const { return id; }
        const vector<ASTExpr *> &GetArgList() const { return argList; }
    };

### 2.2 Parser Tree 到 AST 的转换函数 ###

用于转换的函数 `ASTNode *ParserTreeToAST(struct Node *parserNode);` 位于文件 `src/node.cpp` 中。根据 `parser tree` 中所定义的 `parserNode->name` 来判断当前处理节点的类型。

函数根据不同节点的结构，从 `parser tree` 中提取数据，并将其保存到对应的 `AST` 节点中。在函数递归调用的过程中完成 `AST` 的构建。

### 2.3 AST Print 函数 ###

**函数接口**

对外提供的接口为函数 `void PrintAST(const ASTProgram *program);` 要求传入的参数为指向类 `ASTProgram` 的指针。其实现方式是递归调用打印单个节点的函数 `PrintASTNode(program);` 遍历所有节点并打印。函数位于文件 `src/ast.cpp` 中。

void PrintAST(const ASTProgram *program)
    {
        if (program->GetNodeType() == ASTPROGRAM)
            PrintASTNode(program);
    }

**实现方式**

具体实现的函数是 `void PrintASTNode(const ASTNode *curNode);` 功能为打印单个节点的信息。根据基类的枚举类型成员变量 `typeSpec` 来判断当前节点的类型。定义静态变量 `indent` 保存缩进信息。函数位于文件 `src/ast.cpp` 中。

## 3 优化考虑 ##

在设计 AST 时应该参考 `clang-check` 生成的 AST，将赋值语句单独列出作为一个节点。这样做首先可以降低 AST 的高度；其次来赋值语句作为整体存在，也比分别用变量和表达式标识赋值语句更为合理。

**函数接口**

void PrintAST(const ASTProgram *program)
    {
        if (program->GetNodeType() == ASTPROGRAM)
            PrintASTNode(program);
    }

**实现方式**

## 3 优化考虑 ##