努力不懈的伯克利CS61A之旅：用Python实现Python解释器

2023-10-20 04:39:14

用 Python 编写自己的 Python 解释器：理解 Python 解释的奥秘

词法分析：将代码分解为标记

Python 解释器之旅的第一步是词法分析，它将源代码分解为一系列称为标记的较小单元。就像积木一样，标记是 Python 程序的基础。它们可以是标识符（变量名）、运算符（+、-）、标点符号（;、,）或其他特殊字符。

为了实现词法分析，我们可以使用强大的正则表达式，这是一种模式匹配工具，可以轻松识别和提取代码中的标记。以下代码展示了如何使用正则表达式进行词法分析：

import re

def tokenize(source_code):
  """将源代码分解成标记。

  Args:
    source_code: 源代码。

  Returns:
    标记列表。
  """

  tokens = []
  while source_code:
    match = re.match(r"(\d+)|([a-zA-Z_]\w*)|([()\[\]\{\}])|(\+|-|\*|/|%|=)", source_code)
    if match:
      token = match.group(0)
      tokens.append(token)
      source_code = source_code[len(token):]
    else:
      raise ValueError("Invalid token: {}".format(source_code))

  return tokens

解析：构建抽象语法树

有了标记后，下一步是解析，它将标记序列转换为称为抽象语法树 (AST) 的结构。AST 是源代码结构的层次化表示，它有助于理解和操作代码。

解析器就像语法警察，检查标记序列是否遵循 Python 的语法规则。如果序列有效，解析器将创建一个 AST，其中每个节点都代表源代码的一部分，例如表达式、语句或函数。

以下代码展示了一个递归下降解析器，它可以从标记序列构建 AST：

class Parser:
  """解析器。
  """

  def __init__(self, tokens):
    """初始化解析器。

    Args:
      tokens: 标记列表。
    """

    self.tokens = tokens
    self.index = 0

  def parse(self):
    """解析标记序列。

    Returns:
      抽象语法树。
    """

    return self.expr()

  def expr(self):
    """解析表达式。

    Returns:
      抽象语法树。
    """

    node = self.term()
    while self.index < len(self.tokens) and self.tokens[self.index] == "+":
      self.index += 1
      node = ("+", node, self.term())
    return node

  def term(self):
    """解析项。

    Returns:
      抽象语法树。
    """

    node = self.factor()
    while self.index < len(self.tokens) and self.tokens[self.index] == "*":
      self.index += 1
      node = ("*", node, self.factor())
    return node

  def factor(self):
    """解析因子。

    Returns:
      抽象语法树。
    """

    if self.index < len(self.tokens) and self.tokens[self.index].isdigit():
      node = int(self.tokens[self.index])
      self.index += 1
    elif self.index < len(self.tokens) and self.tokens[self.index] == "(":
      self.index += 1
      node = self.expr()
      self.index += 1
    else:
      raise ValueError("Invalid factor: {}".format(self.tokens[self.index]))
    return node

字节码生成：将 AST 转换为机器可读格式

有了 AST 之后，下一步是生成字节码，这是一种中间语言，由虚拟机解释执行。字节码的创建过程称为字节码生成。

字节码生成器会遍历 AST，并根据其结构生成相应的字节码指令。这些指令代表了应该执行的操作，例如加载常量、执行算术运算或返回结果。

以下代码展示了一个简单的字节码生成器：

class BytecodeGenerator:
  """字节码生成器。
  """

  def __init__(self, ast):
    """初始化字节码生成器。

    Args:
      ast: 抽象语法树。
    """

    self.ast = ast
    self.bytecode = []

  def generate(self):
    """生成字节码。

    Returns:
      字节码。
    """

    self.visit(self.ast)
    return self.bytecode

  def visit(self, node):
    """访问节点。

    Args:
      node: 节点。
    """

    if isinstance(node, int):
      self.bytecode.append(("LOAD_CONST", node))
    elif isinstance(node, tuple):
      op, left, right = node
      self.visit(left)
      self.visit(right)
      if op == "+":
        self.bytecode.append(("ADD",))
      elif op == "-":
        self.bytecode.append(("SUB",))
      elif op == "*":
        self.bytecode.append(("MUL",))
      elif op == "/":
        self.bytecode.append(("DIV",))
    else:
      raise ValueError("Invalid node: {}".format(node))

虚拟机：解释字节码并生成结果

最后一步是虚拟机，它解释字节码并执行相应的操作。虚拟机就像一台微型计算机，它有一个栈来存储数据，以及一个指令指针来跟踪要执行的指令。

虚拟机逐条执行字节码指令，加载常量、执行算术运算，最后返回结果。以下代码展示了一个简单的虚拟机：

class VirtualMachine:
  """虚拟机。
  """

  def __init__(self, bytecode):
    """初始化虚拟机。

    Args:
      bytecode: 字节码。
    """

    self.bytecode = bytecode
    self.stack = []
    self.ip = 0

  def run(self):
    """运行虚拟机。

    Returns:
      运行结果。
    """

    while self.ip < len(self.bytecode):
      op, *args = self.bytecode[self.ip]
      if op == "LOAD_CONST":
        self.stack.append(args[0])
      elif op == "ADD":
        self.stack.append(self.stack.pop() + self.stack.pop())
      elif op == "SUB":
        self.stack.append(self.stack.pop() - self.stack.pop())
      elif op == "MUL":
        self.stack.append(self.stack.pop() * self.stack.pop())
      elif op == "DIV":
        self.stack.append(self.stack.pop() / self.stack.pop())
      else:
        raise ValueError("Invalid opcode: {}".format(op))
      self.ip += 1

    return self.stack.pop()