这一部分，我们研究语义分析中剩下的的流程和类型检查。

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）