第147集：条件语句的中间代码生成

核心知识点讲解

条件语句的分类

在编程语言中，条件语句通常可以分为以下几类：

if语句：单分支条件语句，如 if (condition) { statement }。
if-else语句：双分支条件语句，如 if (condition) { statement1 } else { statement2 }。
if-else if-else语句：多分支条件语句，如 if (c1) { s1 } else if (c2) { s2 } else { s3 }。
嵌套条件语句：条件语句中嵌套其他条件语句。

条件语句的中间代码生成原理

条件语句的中间代码生成主要涉及到跳转指令的生成。编译器会为条件语句生成以下类型的中间代码：

条件跳转指令：根据条件表达式的值决定跳转到哪个标签。
无条件跳转指令：用于跳过else分支或整个条件语句。
标签：用于标记跳转的目标位置。

if语句的中间代码生成

if语句的形式为：

if (condition) {
    statement
}

生成if语句的中间代码步骤如下：

生成条件表达式的中间代码：计算 condition 的值，结果存储在临时变量中。
生成条件跳转指令：如果条件为假，跳转到 L1（if语句结束后的位置）。
生成语句的中间代码：生成 statement 的中间代码。
生成标签：在语句结束后添加标签 L1。

例如，对于if语句：

if (x > 0) {
    y = 1;
}

生成的中间代码如下：

if x > 0 goto L1
goto L2
L1: y = 1
L2:

if-else语句的中间代码生成

if-else语句的形式为：

if (condition) {
    statement1
} else {
    statement2
}

生成if-else语句的中间代码步骤如下：

生成条件表达式的中间代码：计算 condition 的值，结果存储在临时变量中。
生成条件跳转指令：如果条件为真，跳转到 L1（then分支的开始）。
生成无条件跳转指令：跳转到 L2（else分支的开始）。
生成标签L1：然后生成 statement1 的中间代码。
生成无条件跳转指令：跳转到 L3（if-else语句结束后的位置）。
生成标签L2：生成 statement2 的中间代码。
生成标签L3：标记if-else语句的结束。

例如，对于if-else语句：

if (x > 0) {
    y = 1;
} else {
    y = 0;
}

生成的中间代码如下：

if x > 0 goto L1
goto L2
L1: y = 1
goto L3
L2: y = 0
L3:

if-else if-else语句的中间代码生成

if-else if-else语句的形式为：

if (condition1) {
    statement1
} else if (condition2) {
    statement2
} else {
    statement3
}

生成if-else if-else语句的中间代码步骤如下：

生成条件表达式condition1的中间代码：计算 condition1 的值，结果存储在临时变量中。
生成条件跳转指令：如果条件为真，跳转到 L1（第一个then分支的开始）。
生成无条件跳转指令：跳转到 L2（第一个else if的开始）。
生成标签L1：生成 statement1 的中间代码。
生成无条件跳转指令：跳转到 L6（整个if-else if-else语句结束后的位置）。
生成标签L2：生成条件表达式condition2的中间代码。
生成条件跳转指令：如果条件为真，跳转到 L3（第二个then分支的开始）。
生成无条件跳转指令：跳转到 L4（else分支的开始）。
生成标签L3：生成 statement2 的中间代码。
生成无条件跳转指令：跳转到 L6。
生成标签L4：生成 statement3 的中间代码。
生成标签L6：标记整个语句的结束。

短路求值的中间代码生成

在逻辑表达式中，存在短路求值的现象：

逻辑与（&&）：如果第一个操作数为假，就不需要计算第二个操作数。
逻辑或（||）：如果第一个操作数为真，就不需要计算第二个操作数。

生成短路求值的中间代码需要使用条件跳转指令来实现这种短路行为。

例如，对于表达式 a && b，生成的中间代码如下：

if !a goto L1
if !b goto L1
L1:

对于表达式 a || b，生成的中间代码如下：

if a goto L1
if b goto L1
L1:

实用案例分析

案例1：简单if语句

示例代码

if (x > y) {
    max = x;
}

生成的三地址码

if x > y goto L1
goto L2
L1: max = x
L2:

案例2：if-else语句

示例代码

if (x > 0) {
    y = 1;
} else {
    y = -1;
}

生成的三地址码

if x > 0 goto L1
goto L2
L1: y = 1
goto L3
L2: y = -1
L3:

案例3：if-else if-else语句

示例代码

if (score >= 90) {
    grade = 'A';
} else if (score >= 80) {
    grade = 'B';
} else if (score >= 70) {
    grade = 'C';
} else {
    grade = 'D';
}

生成的三地址码

if score >= 90 goto L1
goto L2
L1: grade = 'A'
goto L6
L2: if score >= 80 goto L3
goto L4
L3: grade = 'B'
goto L6
L4: if score >= 70 goto L5
goto L6
L5: grade = 'C'
goto L6
L6: grade = 'D'

案例4：嵌套条件语句

示例代码

if (x > 0) {
    if (y > 0) {
        quadrant = 1;
    } else {
        quadrant = 4;
    }
} else {
    if (y > 0) {
        quadrant = 2;
    } else {
        quadrant = 3;
    }
}

生成的三地址码

if x > 0 goto L1
goto L4
L1: if y > 0 goto L2
goto L3
L2: quadrant = 1
goto L6
L3: quadrant = 4
goto L6
L4: if y > 0 goto L5
goto L6
L5: quadrant = 2
goto L6
L6: quadrant = 3

案例5：带短路求值的条件语句

示例代码

if (a && b || c) {
    x = 1;
} else {
    x = 0;
}

生成的三地址码

if !a goto L1
if !b goto L1
goto L2
L1: if !c goto L3
goto L2
L2: x = 1
goto L4
L3: x = 0
L4:

案例6：条件表达式（三元运算符）

示例代码

x = (a > b) ? a : b;

生成的三地址码

if a > b goto L1
goto L2
L1: x = a
goto L3
L2: x = b
L3:

代码实现

下面是一个简单的条件语句中间代码生成器的实现，使用 Python 语言：

class ConditionCodeGenerator:
    def __init__(self):
        self.temp_count = 0
        self.label_count = 0
        self.instructions = []
    
    def new_temp(self):
        """生成新的临时变量名"""
        self.temp_count += 1
        return f"t{self.temp_count}"
    
    def new_label(self):
        """生成新的标签名"""
        self.label_count += 1
        return f"L{self.label_count}"
    
    def generate_expression(self, expr):
        """生成表达式的中间代码
        
        Args:
            expr: 表达式，以元组形式表示，如 ('+', 'a', 'b')
            
        Returns:
            存储表达式结果的临时变量名
        """
        if isinstance(expr, tuple):
            op = expr[0]
            if op == '+' or op == '-' or op == '*' or op == '/':
                # 二元运算符
                left = self.generate_expression(expr[1])
                right = self.generate_expression(expr[2])
                temp = self.new_temp()
                self.instructions.append(f"{temp} = {left} {op} {right}")
                return temp
            elif op == '>' or op == '<' or op == '>=' or op == '<=' or op == '==' or op == '!=':
                # 比较运算符
                left = self.generate_expression(expr[1])
                right = self.generate_expression(expr[2])
                temp = self.new_temp()
                self.instructions.append(f"{temp} = {left} {op} {right}")
                return temp
            elif op == '&&':
                # 逻辑与（短路求值）
                true_label = self.new_label()
                end_label = self.new_label()
                # 生成第一个操作数
                left = self.generate_expression(expr[1])
                # 如果第一个操作数为假，跳转到结束
                self.instructions.append(f"if !{left} goto {end_label}")
                # 生成第二个操作数
                right = self.generate_expression(expr[2])
                # 如果第二个操作数为真，跳转到真标签
                self.instructions.append(f"if {right} goto {true_label}")
                # 否则跳转到结束
                self.instructions.append(f"goto {end_label}")
                # 真标签
                self.instructions.append(f"{true_label}:")
                # 返回真
                temp = self.new_temp()
                self.instructions.append(f"{temp} = 1")
                # 跳转到结束
                self.instructions.append(f"goto {end_label}")
                # 结束标签
                self.instructions.append(f"{end_label}:")
                # 返回假
                temp2 = self.new_temp()
                self.instructions.append(f"{temp2} = 0")
                return temp2
            elif op == '||':
                # 逻辑或（短路求值）
                true_label = self.new_label()
                end_label = self.new_label()
                # 生成第一个操作数
                left = self.generate_expression(expr[1])
                # 如果第一个操作数为真，跳转到真标签
                self.instructions.append(f"if {left} goto {true_label}")
                # 生成第二个操作数
                right = self.generate_expression(expr[2])
                # 如果第二个操作数为真，跳转到真标签
                self.instructions.append(f"if {right} goto {true_label}")
                # 否则跳转到结束
                self.instructions.append(f"goto {end_label}")
                # 真标签
                self.instructions.append(f"{true_label}:")
                # 返回真
                temp = self.new_temp()
                self.instructions.append(f"{temp} = 1")
                # 跳转到结束
                self.instructions.append(f"goto {end_label}")
                # 结束标签
                self.instructions.append(f"{end_label}:")
                # 返回假
                temp2 = self.new_temp()
                self.instructions.append(f"{temp2} = 0")
                return temp2
        else:
            # 常量或变量
            return expr
    
    def generate_if_statement(self, condition, then_stmt):
        """生成if语句的中间代码
        
        Args:
            condition: 条件表达式
            then_stmt: then分支的语句
        """
        # 生成条件表达式的中间代码
        cond_result = self.generate_expression(condition)
        # 生成标签
        then_label = self.new_label()
        end_label = self.new_label()
        # 生成条件跳转指令
        self.instructions.append(f"if !{cond_result} goto {end_label}")
        # 生成then分支的语句
        self.instructions.append(f"{then_label}:")
        self.generate_statement(then_stmt)
        # 生成结束标签
        self.instructions.append(f"{end_label}:")
    
    def generate_if_else_statement(self, condition, then_stmt, else_stmt):
        """生成if-else语句的中间代码
        
        Args:
            condition: 条件表达式
            then_stmt: then分支的语句
            else_stmt: else分支的语句
        """
        # 生成条件表达式的中间代码
        cond_result = self.generate_expression(condition)
        # 生成标签
        then_label = self.new_label()
        else_label = self.new_label()
        end_label = self.new_label()
        # 生成条件跳转指令
        self.instructions.append(f"if {cond_result} goto {then_label}")
        self.instructions.append(f"goto {else_label}")
        # 生成then分支的语句
        self.instructions.append(f"{then_label}:")
        self.generate_statement(then_stmt)
        self.instructions.append(f"goto {end_label}")
        # 生成else分支的语句
        self.instructions.append(f"{else_label}:")
        self.generate_statement(else_stmt)
        # 生成结束标签
        self.instructions.append(f"{end_label}:")
    
    def generate_statement(self, stmt):
        """生成语句的中间代码
        
        Args:
            stmt: 语句，可以是赋值语句、if语句等
        """
        if isinstance(stmt, dict):
            if 'type' in stmt:
                if stmt['type'] == 'assignment':
                    # 赋值语句
                    lvalue = stmt['lvalue']
                    rvalue = stmt['rvalue']
                    result = self.generate_expression(rvalue)
                    self.instructions.append(f"{lvalue} = {result}")
                elif stmt['type'] == 'if':
                    # if语句
                    condition = stmt['condition']
                    then_stmt = stmt['then_stmt']
                    self.generate_if_statement(condition, then_stmt)
                elif stmt['type'] == 'if-else':
                    # if-else语句
                    condition = stmt['condition']
                    then_stmt = stmt['then_stmt']
                    else_stmt = stmt['else_stmt']
                    self.generate_if_else_statement(condition, then_stmt, else_stmt)
    
    def get_instructions(self):
        """获取生成的中间代码指令"""
        return self.instructions

# 测试代码
generator = ConditionCodeGenerator()

# 测试if语句
print("测试if语句:")
if_stmt = {
    'type': 'if',
    'condition': ('>', 'x', 'y'),
    'then_stmt': {
        'type': 'assignment',
        'lvalue': 'max',
        'rvalue': 'x'
    }
}
generator.generate_statement(if_stmt)
for instr in generator.get_instructions():
    print(instr)
print()

# 测试if-else语句
generator2 = ConditionCodeGenerator()
print("测试if-else语句:")
if_else_stmt = {
    'type': 'if-else',
    'condition': ('>', 'x', '0'),
    'then_stmt': {
        'type': 'assignment',
        'lvalue': 'y',
        'rvalue': '1'
    },
    'else_stmt': {
        'type': 'assignment',
        'lvalue': 'y',
        'rvalue': '-1'
    }
}
generator2.generate_statement(if_else_stmt)
for instr in generator2.get_instructions():
    print(instr)
print()

# 测试带短路求值的条件语句
generator3 = ConditionCodeGenerator()
print("测试带短路求值的条件语句:")
if_short_circuit_stmt = {
    'type': 'if-else',
    'condition': ('||', ('&&', 'a', 'b'), 'c'),
    'then_stmt': {
        'type': 'assignment',
        'lvalue': 'x',
        'rvalue': '1'
    },
    'else_stmt': {
        'type': 'assignment',
        'lvalue': 'x',
        'rvalue': '0'
    }
}
generator3.generate_statement(if_short_circuit_stmt)
for instr in generator3.get_instructions():
    print(instr)

运行结果

测试if语句:
t1 = x > y
if !t1 goto L2
L1:
max = x
L2:

测试if-else语句:
t1 = x > 0
if t1 goto L1
goto L2
L1:
y = 1
goto L3
L2:
y = -1
L3:

测试带短路求值的条件语句:
t1 = a
if !t1 goto L4
t2 = b
if t2 goto L1
goto L4
L1:
t3 = 1
goto L4
L4:
t4 = 0
t5 = c
if t5 goto L2
goto L5
L2:
t6 = 1
goto L5
L5:
t7 = 0
if t7 goto L6
goto L7
L6:
x = 1
goto L8
L7:
x = 0
L8:

总结

条件语句的中间代码生成是编译器前端的重要组成部分，它涉及到跳转指令和标签的生成，以实现条件分支的逻辑。对于不同类型的条件语句，如if语句、if-else语句和if-else if-else语句，它们的中间代码生成方式有所不同，但核心都是通过条件跳转和无条件跳转指令来控制程序的执行流程。

在生成条件语句的中间代码时，需要注意以下几点：

标签的管理：合理生成和使用标签，确保跳转的目标位置正确。
短路求值：正确实现逻辑表达式的短路求值行为，提高程序的执行效率。
嵌套条件：处理好嵌套条件语句的中间代码生成，确保嵌套层次的正确性。
代码优化：在生成中间代码时，可以考虑一些简单的优化，如合并相邻的跳转指令等。