c语言语法树节点挂接,简单的C语言解释运行器实现（四）—— 语法分析

上一篇：定义语法

下一篇：语义分析

语法树

是啥

在知道了文法的定义后，我们就要根据文法分析生成语法树了。

语法树可以表达是文法展开的过程，比如i+i*i

对应文法是

E ::= T | E + T | E - T

T ::= F | T * F | T / F

F ::= i

文法展开过程是：

E -> E + T -> T + T -> F + T -> i + T

-> i + T * F -> i + F * F -> i + i * i

根据文法构造的语法树就是：

E

/|\

F + T

| /|\

i F * F

| |

i i

就很清楚了，我们得到语法树后可以计算”中序”遍历的序列，并对每个节点加括号，那么就可以还原原算式和文法的结构。

(i+(i*i))

(-E-----)

F+(-T-)

i F*F

i i

如果是连等式，那么有

a=b=c=d=e=1

=

/ \

a =

/ \

b =

/ \

c =

/ \

d =

/ \

e 1

因为=是右结合的，所以语法树是右偏的。

可以说语法树展现了语句的结构，也展现文法的展开方式。

前置离散数学和数据结构。

语法树实现及节点类型表示参见

https://github.com/huanghongxun/Compiler/blob/master/compiler/syntax_tree.h

https://github.com/huanghongxun/Compiler/blob/master/compiler/syntax_descriptors.h

求值

我们有必要实现一个在语法树上直接运算的程序，这样我们可以在编译期完成常量的计算，计算数组定义时各维大小的表达式(如int a[2 * 3][(int) 3.0 / 2])，以及实现constexpr。

说简单其实可以说简单，我们可以这么写(伪代码)

object eval(AST ast)

{

if (ast->type is binary_operator) // 二元运算符

{

switch (ast->op)

{

case "+": // 两个子树先求值再加和

return eval(ast->children[0]) + eval(ast->children[1]);

case "-": // 两个子树先求值再做差

return eval(ast->children[0]) - eval(ast->children[1]);

... // * / << >> && & || | ^ % ... < > <= >=

}

}

else if (ast->type is unary_operator) // 一元运算符

{

switch (ast->op)

{

case "-":

return -eval(ast->children[0]);

... // + & * ! ~

}

}

else if (ast->type is cast) // 转型

{

switch (ast->cast_to)

{

is int:

return (int)eval(ast->children[0]);

...

}

else if (ast->type is constant)

{

return ast->value;

}

else

throw runtime_error("Unsupported syntax tree type");

}

如果你了解树的话，上面的代码应该很好懂。也就是说，我们先递归求解子树的值，然后根据当前的语法树节点进行计算。

具体实现参见 https://github.com/huanghongxun/Compiler/blob/master/compiler/syntax_tree_evaluation.cpp

不过实际上进行计算的话是需要类型的，如果我们在语义分析阶段完成类型分析后实现会更简单。具体计算数组维度的请参见语义分析代码

https://github.com/huanghongxun/Compiler/blob/master/compiler/semantic_analyzer.cpp

递归下降分析法

例子

递归下降分析法这个名称听起来挺高端的，但是实际上就是对于每条文法都实现一个子程序而已，在介绍实际做法之前，我们先考虑如下的例子：

我们要解析这样的字符串表示A(B(,C(,)),D(,)。

我们定义文法：

C ::= a .. z

R ::= e | C(R,R)

其中R表示定义一棵二叉树，叶节点表示为C(,)。

我们要怎么解析呢？根据递归下降分析法的要求，我们要对每条文法实现一个子程序，文法C无非就是isalpha，我们实现R的解析：

int i = 0;

tree *parse_R()

{

tree *node = new tree;

auto c = str[i]; // 拿到当前的字符

if (isalpha(c)) // 当前的字符是C，我们能匹配到R的第二条

{

i++; // 跳过字母

assert(str[i++] == '('); // 字母下一位必须是左括号

node->left = parse_R(); // 递归匹配R

assert(str[i++] == ','); // 必须使用逗号隔开

node->right = parse_R(); // 递归匹配R

assert(str[i++] == ')'); // 必须以右括号结束

return node;

}

else if (c == ',' || c == ')') // 当前字符不是字母，但可以匹配到R的第一条，因为空的下一位只能是逗号和右括号

{

return null;

}

else // R的两条都没有匹配到，当前字符不是字母，空的下一位却不是逗号和右括号

assert(false); // 不符合语法

}

这样我们就可以解析出树了。这个方法是最快的，我们只需要扫描一遍字符串即可。

实现

接下来我们讨论实际的写法，比如之前定义的

UNIT_3 ::= UNIT_2 | UNIT_3 + UNIT_2 | UNIT_3 - UNIT_2

如果我们直接递归调用UNIT_3实现UNIT_3，肯定是不行的，因为我们程序实现不好做到预判运算符，对于这种递归，我们手动展开UNIT_3：

UNIT_3 ::= UNIT_2 +/- UNIT_2 +/- ... +/- UNIT_2

那么很容易发现，无非就是从左往右匹配UNIT_2，然后我们就会遇到+和-，然后再遇到下一个+和-，也就是说因为从左往右解析，我们自然地完成了符号的左结合特性。我们可以这么实现：

syntax_tree *parse_unit3()

{

syntax_tree *ast = parse_unit2();

while (peek_token() == "+" || peek_token() == "-")

{

string t = next_token();

syntax_tree n_ast = new syntax_tree(descriptor_binary_operator("+"));

n_ast->children.push_back(ast);

n_ast->children.push_back(parse_unit2());

ast = n_ast;

}

return ast;

}

因为更高优先级的已经在parse_unit2处理过了，所以我们能保证更高优先级的一定在子树中，即优先执行更高优先级的运算符。

对于右结合的赋值系列符号，我们可以这么写：

syntax_tree *compiler::syntax_analyzer::parse_unit9()

{

syntax_tree *node = parse_unit8();

if (peek_token("=") || peek_token("+=") || peek_token("-=") || peek_token("/=") || peek_token("%=") || peek_token("*=") || peek_token("|=") || peek_token("&=") || peek_token("^=") || peek_token("<<=") || peek_token(">>="))

{

auto op = next_token();

AST ast = make_shared(descriptor_assign(op.code), op);

ast->children.push_back(node);

ast->children.push_back(parse_unit9());

return ast;

}

else

{

return node;

}

}

因为右结合，所以我们就可以直接按照文法递归实现。

注意

我们在解析语句的时候，会有几种情况，分别是定义变量、表达式、if等特殊功能语句。其中特殊功能语句开头的标识符都比较特别，区分起来很容易，我们不作讨论。我们讨论一下关于区分定义变量和表达式。考虑到两者的开头都允许字母数字下划线组成的标识符，我们必须区分标识符是变量名还是类型，我们需要在语法分析期记录类型表，我们在遇到static，const，long以及类型表中的标识符、或者其他定义的类型修饰符(比如接下来为了实现与解释器交互的内建函数，我们需要__built_in标识，VC的__cdecl和__stdcall等)时，匹配到定义变量，否则如果是变量名，当作表达式处理；如果都不能匹配，那么只能是未声明的类型或者未定义的变量。为了简化问题，更加精确的错误分析我们就不讨论了。

我们甚至可以合并函数和变量定义的文法。

具体实现参考

https://github.com/huanghongxun/Compiler/blob/master/compiler/syntax_analyzer.cpp

https://github.com/huanghongxun/Compiler/blob/master/compiler/parsers.cpp

上一篇：定义语法

下一篇：语义分析