logo

4、语义分析

作者
Modified on
Reading time
8 分钟阅读:..评论:..

语义分析（Semantic Analysis）是编译过程中的第三个阶段。语义分析器的任务是检查源代码的语义是否正确。例如，类型检查、作用域解析等。语义分析器通常会构建和维护符号表，并进行各种语义检查，以确保程序的正确性。

4.1.1 语义分析的功能

  • 符号表管理：记录和管理源代码中的符号信息，如变量、函数、类型等。
  • 类型检查：确保操作数和操作符的类型兼容。
  • 作用域和命名空间解析：确保符号在正确的作用域内定义和使用。
  • 语义规则检查：检查程序是否遵循语言的语义规则，例如函数调用参数和形参匹配等。

4.1.2 语义分析器的输入和输出

  • 输入：抽象语法树（AST）和来自词法分析器的记号序列。
  • 输出：经过语义检查的抽象语法树和符号表。

4.2 符号表管理

符号表是语义分析器的重要数据结构，用于记录和管理源代码中的符号信息。符号表通常以哈希表或链表的形式实现，每个符号记录包含符号的名称、类型、作用域等信息。

4.2.1 符号表的基本操作

  • 插入符号：将新符号插入符号表中。
  • 查找符号：在符号表中查找指定符号的信息。
  • 删除符号：在符号表中删除指定符号（通常用于退出作用域时）。

示例：符号表的数据结构（使用 TypeScript）

interface SymbolInfo {
    name: string;
    type: string;
    scope: string;
    // 其他信息
}

class SymbolTable {
    private table: Map<string, SymbolInfo>;

    constructor() {
        this.table = new Map<string, SymbolInfo>();
    }

    insert(symbol: SymbolInfo) {
        this.table.set(symbol.name, symbol);
    }

    lookup(name: string): SymbolInfo | undefined {
        return this.table.get(name);
    }

    remove(name: string) {
        this.table.delete(name);
    }
}

符号表管理示意图

4.3 类型检查

类型检查是语义分析的重要任务之一，用于确保操作数和操作符的类型兼容。类型检查可以防止类型错误，如将整数赋值给字符串变量或将浮点数作为数组索引等。

4.3.1 类型检查的基本操作

  • 类型推断：根据上下文推断表达式的类型。
  • 类型匹配：检查操作数和操作符的类型是否匹配。
  • 类型转换：在必要时进行类型转换（如自动类型提升）。

示例：类型检查（使用 Java）

public class TypeChecker {

    private SymbolTable symbolTable;

    public TypeChecker(SymbolTable symbolTable) {
        this.symbolTable = symbolTable;
    }

    public void check(ASTNode node) {
        switch (node.getType()) {
            case ASSIGNMENT:
                checkAssignment(node);
                break;
            case BINARY_OP:
                checkBinaryOperation(node);
                break;
            // 其他类型检查
        }
    }

    private void checkAssignment(ASTNode node) {
        String varName = node.getLeft().getValue();
        String varType = symbolTable.lookup(varName).getType();
        String exprType = inferType(node.getRight());

        if (!varType.equals(exprType)) {
            throw new RuntimeException("类型不匹配：不能将 " + exprType + " 赋值给 " + varType);
        }
    }

    private void checkBinaryOperation(ASTNode node) {
        String leftType = inferType(node.getLeft());
        String rightType = inferType(node.getRight());

        if (!leftType.equals(rightType)) {
            throw new RuntimeException("类型不匹配：操作数类型不同");
        }
    }

    private String inferType(ASTNode node) {
        // 类型推断逻辑
        return node.getType().name();
    }
}

类型检查流程示意图

4.4 作用域与命名空间

作用域和命名空间用于确定符号的可见性和生存期。作用域表示符号在程序中的可见范围，命名空间用于避免符号命名冲突。

4.4.1 作用域的种类

  • 全局作用域：适用于整个程序的符号，如全局变量和函数。
  • 局部作用域：适用于特定代码块内的符号，如函数参数和局部变量。
  • 嵌套作用域：作用域可以嵌套，如函数内的代码块。

4.4.2 命名空间的管理

  • 命名空间定义：定义命名空间，确保符号在不同命名空间内互不冲突。
  • 命名空间解析：解析符号时，考虑命名空间的层次结构。

示例：作用域和命名空间管理（使用 Python）

class SymbolTable:
    def __init__(self):
        self.global_scope = {}
        self.scopes = [{}]

    def enter_scope(self):
        self.scopes.append({})

    def exit_scope(self):
        self.scopes.pop()

    def insert(self, name, symbol):
        self.scopes[-1][name] = symbol

    def lookup(self, name):
        for scope in reversed(self.scopes):
            if name in scope:
                return scope[name]
        return self.global_scope.get(name)

    def insert_global(self, name, symbol):
        self.global_scope[name] = symbol

作用域和命名空间管理示意图

4.5 语义规则的检查

语义规则检查是指检查程序是否遵循语言的语义规则，如函数调用中的参数和形参匹配、数组索引的合法性等。

4.5.1 常见的语义规则

  • 函数调用匹配：检查函数调用中的实参和形参是否匹配。
  • 数组索引检查：检查数组索引是否为整数类型。
  • 类型一致性：确保表达式中的变量和操作符类型一致。

示例：语义规则检查（使用 JavaScript）

class SemanticChecker {
    constructor(symbolTable) {
        this.symbolTable = symbolTable;
    }

    check(node) {
        switch (node.type) {
            case 'FunctionCall':
                this.checkFunctionCall(node);
                break;
            case 'ArrayAccess':
                this.checkArrayAccess(node);
                break;
            // 其他语义检查
        }
    }

    checkFunctionCall(node) {
        const

当然，以下是接续部分的内容：

示例：语义检查代码

class SemanticChecker {
    constructor(symbolTable) {
        this.symbolTable = symbolTable;
    }

    check(node) {
        switch (node.type) {
            case 'FunctionCall':
                this.checkFunctionCall(node);
                break;
            case 'ArrayAccess':
                this.checkArrayAccess(node);
                break;
            // 其他语义检查
        }
    }

    checkFunctionCall(node) {
        const funcName = node.children[0].name;
        const funcSymbol = this.symbolTable.lookup(funcName);
        if (!funcSymbol) {
            throw new Error(`函数 ${funcName} 未定义`);
        }
        const expectedArgs = funcSymbol.params.length;
        const actualArgs = node.children.length - 1;
        if (expectedArgs !== actualArgs) {
            throw new Error(`函数 ${funcName} 参数数量不匹配`);
        }
    }

    checkArrayAccess(node) {
        const arrayName = node.children[0].name;
        const indexNode = node.children[1];
        const indexType = this.inferType(indexNode);
        if (indexType !== 'int') {
            throw new Error(`数组索引必须为整数类型`);
        }
    }

    inferType(node) {
        // 类型推断逻辑
        return node.type;
    }
}

4.6 作用域和命名空间解析

在编译过程中，作用域和命名空间解析是用于确定符号定义和使用的有效范围。不同的编程语言可能有不同的作用域规则，但基本原则是相同的。

示例：作用域管理代码（使用 Python）

class Scope:
    def __init__(self):
        self.global_scope = {}
        self.scopes = [{}]

    def enter_scope(self):
        self.scopes.append({})

    def exit_scope(self):
        self.scopes.pop()

    def define_symbol(self, name, symbol):
        self.scopes[-1][name] = symbol

    def lookup_symbol(self, name):
        for scope in reversed(self.scopes):
            if name in scope:
                return scope[name]
        return self.global_scope.get(name)

    def define_global(self, name, symbol):
        self.global_scope[name] = symbol

4.7 语义分析器的实现

语义分析器的实现可以分为以下几个步骤：

  1. 构建符号表：记录所有符号的信息。
  2. 类型检查：确保所有表达式和操作的类型合法。
  3. 作用域解析：确保所有符号在正确的作用域内定义和使用。
  4. 语义规则检查：检查程序是否遵循语言的语义规则。

示例：语义分析器集成代码（使用 Java）

public class SemanticAnalyzer {
    private SymbolTable symbolTable;

    public SemanticAnalyzer() {
        this.symbolTable = new SymbolTable();
    }

    public void analyze(ASTNode root) {
        buildSymbolTable(root);
        checkTypes(root);
        resolveScopes(root);
        checkSemanticRules(root);
    }

    private void buildSymbolTable(ASTNode node) {
        // 构建符号表逻辑
    }

    private void checkTypes(ASTNode node) {
        TypeChecker typeChecker = new TypeChecker(symbolTable);
        typeChecker.check(node);
    }

    private void resolveScopes(ASTNode node) {
        // 作用域解析逻辑
    }

    private void checkSemanticRules(ASTNode node) {
        SemanticChecker semanticChecker = new SemanticChecker(symbolTable);
        semanticChecker.check(node);
    }
}

4.8 语义分析中的错误处理

语义分析器需要处理各种语义错误，如类型不匹配、未定义符号、作用域错误等。错误处理策略包括：

  • 错误报告：在发现错误时，及时报告错误信息，帮助程序员定位问题。
  • 错误恢复：尝试从错误中恢复，继续进行语义分析，避免因一个错误而中断整个编译过程。

示例：错误处理代码（使用 JavaScript）

class SemanticChecker {
    constructor(symbolTable) {
        this.symbolTable = symbolTable;
    }

    check(node) {
        try {
            switch (node.type) {
                case 'FunctionCall':
                    this.checkFunctionCall(node);
                    break;
                case 'ArrayAccess':
                    this.checkArrayAccess(node);
                    break;
                // 其他语义检查
            }
        } catch (error) {
            console.error(`语义错误: ${error.message} at line ${node.line}`);
            this.recover(node);
        }
    }

    checkFunctionCall(node) {
        const funcName = node.children[0].name;
        const funcSymbol = this.symbolTable.lookup(funcName);
        if (!funcSymbol) {
            throw new Error(`函数 ${funcName} 未定义`);
        }
        const expectedArgs = funcSymbol.params.length;
        const actualArgs = node.children.length - 1;
        if (expectedArgs !== actualArgs) {
            throw new Error(`函数 ${funcName} 参数数量不匹配`);
        }
    }

    checkArrayAccess(node) {
        const arrayName = node.children[0].name;
        const indexNode = node.children[1];
        const indexType = this.inferType(indexNode);
        if (indexType !== 'int') {
            throw new Error(`数组索引必须为整数类型`);
        }
    }

    inferType(node) {
        // 类型推断逻辑
        return node.type;
    }

    recover(node) {
        // 错误恢复逻辑
        // 例如，跳过当前节点，继续分析下一个节点
    }
}

4.9 语义分析的性能优化

为了提高语义分析器的效率，可以采用以下几种优化策略：

  1. 符号表管理优化：使用高效的数据结构（如哈希表）管理符号表，提高查找速度。
  2. 类型检查优化：结合类型推断和静态分析技术，提高类型检查的效率。
  3. 并行处理：在多核处理器上并行处理不同的语义检查任务，提高分析速度。

在本章中，我们详细介绍了语义分析的基本概念、符号表管理、类型检查、作用域解析及命名空间管理、语义规则检查、语义分析器的实现、错误处理以及性能优化等内容。通过结合 Mermaid 图表，我们直观地展示了语义分析器的工作原理和各个步骤的具体实现。

关键要点

  • 符号表管理：记录和管理源代码中的符号信息，如变量、函数、类型等。
  • 类型检查：确保操作数和操作符的类型兼容。
  • 作用域解析：确保符号在正确的作用域内定义和使用。
  • 语义规则检查：检查程序是否遵循语言的语义规则。
  • 错误处理：及时报告错误信息，并尝试从错误中恢复，继续进行语义分析。
  • 性能优化：通过符号表管理优化、类型检查优化和并行处理，提高语义分析器的效率。

在接下来的章节中，我们将深入探讨中间代码生成的基本概念和实现方法，进一步了解编译器的第四个重要阶段。

< 3、编译语法分析
5、中间代码生成 >