这一部分，我们研究语义分析中剩下的的流程和类型检查。
6.2 流程检查
还是以我们前面举例使用的那段源代码作为例子，经过声明检查的错误提醒，可以改成：
int main()
{
int a = 1;
return;
}
很重要的一步。但是，这段代码仍然是有语法错误的，因为没有返回值。这个错误将会很快检查出来。
我们还是遍历那棵抽象语法树，与声明检查重点遍历变量不同，流程检查将重点遍历语句。这一点是非常直观，也是容易理解的。仿照声明检查的方法，我们再定义一个遍历的类，然后定义将会用到的节点函数。
class FlowControlVisitor(NodeVisitor):
def visit_AST(self, node):
node.has_return = False
def visit_TranslationUnit(self, node):
self.visit_list(node.nodes)
def visit_FunctionDefn(self, node):
node.body.visit(self)
if node.return_type != VOID and not node.body.has_return:
raise Exception("Function doesn't return through all branches." )
def visit_CompoundStatement(self, node):
node.statements.visit(self)
node.has_return = node.statements.has_return
def visit_StatementsList(self, node):
node.has_return = False
for stmt in node.nodes:
stmt.visit(self)
def visit_ReturnStatement(self, node):
node.has_return = True
为了实现返回值检查，我们为这些节点定义了has_return的属性。这个属性从节点FunctionDefn逐渐渗透到模板节点，只在遇到节点ReturnStatement时才返回真，这样，当再次回溯到FunctionDefn节点时，就可以做出判断，返回值检查也就实现了。
此外，在流程检查中，还有一类错误需要关注：关键字break和continue只能在循环语句中才能使用。这部分内容，我们重点关注循环节点及其相关的continue, break节点：
def __init__(self):
self.in_loop = False
def visit_ForLoop(self, node):
self.in_loop = True
node.stmt.visit(self)
def visit_BreakStatement(self, node):
if not self.in_loop:
raise Exception('Break statement outside of loop.')
def visit_ContinueStatement(self, node):
if not self.in_loop:
raise Exception('Continue statement outside of loop.')
通过引入成员变量in_loop，进入函数体时初始化为假，而只在循环节点入口才设置in_loop为真，之后再遍历到return和break节点，语法就是正确的，否则语法错误。但是，对于下面这种情况：
int main() // in_loop = false 0
{
int k = 0;
for (int j = 0; j < 10; j = j + 1) { // in_loop = true 1
for (int i = 0; i < 10; i = i + 1) { // in_loop = true 2
if (i > 5)
break;
}
int i = 0;
if (i < 5) { // in_loop = true 1
i = i + 1;
continue;
}
}
if (k < 5) { // in_loop = false 0
continue;
}
}
continue出现在结构体外，但是由于第一个循环体改变了in_loop的属性而没有复原，使得对continue的检查将出现错误。此外，也不能简单地将其重置为假，因为循环是可以嵌套的，否则将改变in_loop原来的正确状态。因此，采用栈结构对变量进行保存：
def visit_ForLoop(self, node):
super_in_loop = self.in_loop
self.in_loop = True
node.stmt.visit(self)
self.in_loop = super_in_loop
用super_in_loop来暂时保存当前的in_loop属性，当遍历离开循环节点时，又恢复到原来的状态。
最后，合并has_return和in_loop的使用，就实现了流程检查。
6.3 类型检查
我们先来看下面这段C代码：
int *a;
int b;
a = *b; // error 1
b = a; // error 2
a = &5; // error 3
这段代码，我们列出了三个语法错误，分别是：
- error 1: b不是指针类型
- error 2: 将指针类型转换到int类型
- error 3: 对右值取地址
这些就是类型检查将要做的事情。我们在前面花费很大力气定义的那些类型节点，它们将在这里进行排上用场。同样地，再定义一个遍历类：
class TypeCheckVisitor(NodeVisitor):
pass
在定义节点函数之前，我们先定义一个叶子函数，也就是辅助判断函数，来帮助我们比较两个变量的类型：
def compare_types(self, from_type, to_type):
conflict = False
from_str = from_type.to_str()
to_str = to_type.to_str()
if from_str != to_str:
if from_str == 'char':
if to_str == 'int':
pass
else:
conflict = True
else:
conflict = True
if conflict:
raise Exception(f"Cannot convert from {from_str} to {to_str}.")
通过函数to_str()（在类型节点中添加为成员函数）获取将要比较的两个type的具体类型，我们允许char到int的转换，但对于其它情况，将会抛出异常。
接下来，我们定义所关心的节点函数：
def visit_AST(self, node):
pass
def visit_AddrOf(self, node):
node.expr.visit(self)
if not node.expr.is_lvalue():
raise Exception(f"Address-of (&) target has no address!")
def visit_Pointer(self, node):
node.expr.visit(self)
if node.expr.type.to_str() == 'pointer':
node.set_lvalue()
else:
raise Exception(f"Pointer dereference (*) target is not a pointer!")
def visit_BinOp(self, node):
node.left.visit(self)
node.right.visit(self)
if node.op == '=':
if not node.left.is_lvalue():
raise Exception(f"{node.left.expr} is an invalid lvalue: not an address!.")
self.compare_types(node.right.type, node.left.type)
在前面，我们通过派生出具体的类型来罗列单目运算符的表达式，这里就具有实际意义了。因为，我们可可以单独创建节点函数进行处理。在BinOp中，通过调用compare_types，我们解决了error 2；通过定义节点Pointer的函数，我们解决了error 1；而对于error 3，可用上面代码中的两个函数set_lvalue()和is_lvalue()来辅助判断。
那么，那些值是左值呢？我们需要回到最开始声明检查中定义的那个节点函数里去判断：声明过的变量，我们将其加入_symbols中，如果后面使用的变量就在这个表中，那么这个变量就认为是左值，因为它被分配了存储空间。具体细节，我们将在生成汇编代码中进一步说明。这样，修改那里的代码为：
def visit_Id(self, node):
symbol = self.current_scope.lookup(node.expr)
if symbol is not None:
node.set_lvalue()
else:
comment = f"Identifier '{node.expr}' not found."
raise Exception(comment)
这样，就和TypeCheckVisitor关联上了。当然，还有其它地方需要进行类型比较的地方，比如ReturnStatement节点：
def visit_FunctionDefn(self, node):
self.curr_func = node
node.body.visit(self)
def visit_ReturnStatement(self, node):
node.expr.visit(self)
return_type = self.curr_func.return_type
self.compare_types(node.expr.type, return_type)
我们同样增加了一个成员变量curr_func，使得我们能够在ReturnStatement节点中拿返回值的类型与函数定义的返回值类型进行比较，从而发现错误。
语义分析的内容基本上就到此为止。这里，我们只是简单地覆盖了C语言中非常常见的语法错误。但是，通过熟悉了遍历方式，定义节点函数访问节点进行节点内容分析，大家可以触类旁通，通过不断添加和完善节点函数，继续在这棵抽象语法树上进行更多的语法检查。
实现简易的C语言编译器（part 0）
实现简易的C语言编译器（part 1）
实现简易的C语言编译器（part 2）
实现简易的C语言编译器（part 3）
实现简易的C语言编译器（part 4）
实现简易的C语言编译器（part 5）
实现简易的C语言编译器（part 6）
实现简易的C语言编译器（part 7）
实现简易的C语言编译器（part 8）
实现简易的C语言编译器（part 10）
实现简易的C语言编译器（part 11）
