动手实现编译器（二）——语法分析

在这一节中，将介绍语法分析器。
在上一节的词法分析上实现SysY语言语法分析，来解析类似2 - 15 / 7 + 3 * 8 T_EOF（T_EOF表示终结符）

由于SysY语言的语法是递归的，因此可以递归解析它。可以编写如下所示的伪代码：

递归解析函数() 
{
	扫描并检查第一个令牌是一个数字。如果不是，则返回错误。
	获取下一个单词。
	如果到达输入的末尾，则返回结果。
	否则，调用递归解析函数()。
}

抽象语法树

为了进行语义分析，我们需要代码来解释识别的输入，或将其转换为另一种格式，例如汇编代码。因此我们首先要将输入转换为语法分析树，也称为 AST。
AST 的节点结构：

// AST节点类型
enum
{
    A_ADD, A_SUB, A_MUL, A_DIV, A_MOD, A_INT
};

// 抽象语法树结构
struct ASTnode
{
    int op;				        // 节点的操作类型
    struct ASTnode *left;
    struct ASTnode *right;
    int intvalue;				// 整数节点的值，没有子树
};

构建AST

用以下代码构建AST：

struct ASTnode *mkastnode(int op, struct ASTnode *left, struct ASTnode *right, int intvalue)
{
    struct ASTnode *n;
    n = (struct ASTnode *) malloc(sizeof(struct ASTnode));
    if (n == NULL)
    {
        fprintf(stderr, "Unable to malloc in mkastnode()\n");
        exit(1);
    }
    n->op = op;
    n->left = left;
    n->right = right;
    n->intvalue = intvalue;
    return n;
}


// 生成AST叶子节点
struct ASTnode *mkastleaf(int op, int intvalue)
{
    return mkastnode(op, NULL, NULL, intvalue);
}

// 生成只有一个左孩子的一元AST节点
struct ASTnode *mkastunary(int op, struct ASTnode *left, int intvalue)
{
    return (mkastnode(op, left, NULL, intvalue));
}

简单的表达式解析器

为了将词法分析中的单词用作AST节点操作值。首先，定义一个函数将单词映射到AST节点操作值。代码如下：

// 将单词转换为AST操作
int token_op(int token)
{
    switch (token)
    {
        case T_ADD:    return A_ADD;
        case T_SUB:    return A_SUB;
        case T_MUL:    return A_MUL;
        case T_DIV:    return A_DIV;
        default:    fprintf(stderr, "unknown token in token_op() on line %d\n", Line);
                    exit(1);
    }
}

然后定义一个函数来检查下一个单词是否为整数，并生成一个AST节点来储存整数值。

为此首先定义一个全局变量Token，表示从输入中扫描来的最新单词

struct token	Token;      //当前扫描单词

函数代码如下：

// 解析一个整数单词并返回表示它的AST节点
struct ASTnode *primary()
{
    struct ASTnode *n;
    // 对于整数单词，为其生成一个AST叶子节点并扫描下一个单词。
    // 否则，语法错误。
    switch (Token.token)
    {
        case T_INT:  
            n = mkastleaf(A_INT, Token.intvalue);
            scan(&Token);
            return n;
        default:
            fprintf(stderr, "syntax error on line %d\n", Line);
            exit(1);
    }
}

最后将上面的几个函数组装为语法分析器，代码如下：

struct ASTnode *binexpr(void)
{
    struct ASTnode *n, *left, *right;
    int nodetype;

    // 获取左节点的整数，同时获取下一个单词
    left = primary();

    // 如果下一个单词是文件结尾，则返回左节点
    if (Token.token == T_EOF)   return left;

    // 从单词映射到节点类型
    nodetype = token_op(Token.token);

    // 获取下一个单词
    scan(&Token);

    // 递归得到右子树
    right = binexpr();

    // 将左、右子树合并成一棵树
    n = mkastnode(nodetype, left, right, 0);
    return n;
}

为了直观显示结果，添加一个结果输出该函数，代码如下：

// AST操作符
char *ASTop[] = { "+", "-", "*", "/" };

// 给定一个AST，返回一个表达式
int interpretAST(struct ASTnode *n)
{
    int leftval, rightval;

    // 获得左、右子树值
    if (n->left)    leftval = interpretAST(n->left);
    if (n->right)   rightval = interpretAST(n->right);

    // 调试：打印将要做的事情
    if (n->op == A_INT)    printf("int %d\n", n->intvalue);
    else    printf("%d %s %d\n", leftval, ASTop[n->op], rightval);

    switch (n->op)
    {
        case A_ADD:    return leftval + rightval;
        case A_SUB:    return leftval - rightval;
        case A_MUL:    return leftval * rightval;
        case A_DIV:    return leftval / rightval;
        case A_INT:    return n->intvalue;
        default:    fprintf(stderr, "Unknown AST operator %d\n", n->op);
                    exit(1);
    }
}

同时修改main()函数为以下代码，来验证结果

// 用法 compiler -o -s outfile infile
int main(int argc, char *argv[])
{
    struct ASTnode *n;
    if(argc != 4)
    {
        fprintf(stderr, "compiler -o -s outfile infile\n");
        exit(1);
    }
    init();
    if ((Infile = fopen(argv[4], "r")) == NULL)
    {
        fprintf(stderr, "Unable to open %s: %s\n", argv[1], strerror(errno));
        exit(1);
    }
    scan(&Token);			            // 从输入中获得第一个单词
    n = binexpr();		                // 解析表达式
    printf("%d\n", interpretAST(n));	// 计算最终的结果
}

输入：

2 - 15 / 7 + 3 * 8

输出：

int 2
int 15
int 7
int 3
int 8
3 * 8
7 + 24
15 / 31
2 - 0
2

输入：

2 - 15 / 7 + 3 * * 8

输出：

syntax error on line 1

输入：

2 8 - 15 / 7 + 3 * 8

输出：

unknown token in token_op() on line 1

可以看到这个语法分析器可以识别SysY语言的部分语法，并检查编译器的输入是否符合该语法，但不能处理不同的运算符优先级。就目前而言，该代码将所有运算符都视为具有相同的优先级。在下一节，将加入对表达式进行语义分析的代码以获得正确的数学结果。