如果你正在学习计算机组成原理，却感觉那些抽象的概念——ALU、寄存器、内存、指令集——离你很远，只是在纸上谈兵；如果你想知道自己写的代码，究竟是如何一步步变成屏幕上跳动的像素，驱动游戏手柄的每一次点击；那么，这篇文章就是为你准备的。
我们常常被告知，计算机科学是理论与实践的结合，但“计算机组成原理”这门课，却常常卡在理论与实践的断层之间。你学了一堆门电路、时序图、汇编指令，却不知道它们如何协同工作，最终运行一个哪怕最简单的程序。今天要介绍的，正是解决这个核心痛点的“神级”实践项目：从与非门开始，亲手构建一台能运行俄罗斯方块的现代计算机。
这个项目源自希伯来大学的著名课程《从第一性原理构建现代计算机》（Build a Modern Computer from First Principles）。它不是一个模拟器，也不是一个观看动画，而是一个要求你从最底层的逻辑门（Nand Gate）开始，用硬件描述语言（HDL）逐层搭建CPU、内存、计算机，最终在其上编写汇编器、编译器，并运行高级语言（如Jack语言）编写的俄罗斯方块游戏。
本文将带你深入拆解这个项目的后半部分（2/2），即从构建出完整的计算机硬件平台（Hack Computer）之后，到最终运行俄罗斯方块的全过程。你会发现，它真正解决的，不是“知道”计算机如何工作，而是让你“亲手实现”并“亲眼见证”整个软件栈的诞生。读完本文，你将清晰掌握：
- 如何从硬件描述语言（HDL）定义的计算机，过渡到可编程的软件平台。
- 汇编器（Assembler）和编译器（Compiler）的核心工作原理与实现要点。
- 高级语言（Jack）如何设计，并最终被编译成机器码。
- 一个完整的“俄罗斯方块”游戏，是如何从高级语言代码，层层翻译，最终在你自己构建的硬件上运行的。
这不仅是一次深刻的学习，更是一次无与伦比的、构建完整计算机系统的工程实践。下面，我们就从最核心的问题开始。
1. 这篇文章真正要解决的问题：理论与实践的鸿沟
很多计算机专业的学生都有这样的困惑：我学了C语言、数据结构、操作系统、组成原理，但这些知识像散落的珍珠，无法串联成一个完整的画面。特别是组成原理，学了ALU、寄存器、内存、总线，但这些东西和我在屏幕上看到的“Hello World”或者一个游戏，到底有什么关系？
传统的教学和教材往往停留在分层讲解和理论推演上：
- 教材：告诉你CPU有取指、译码、执行、访存、写回五个阶段。
- 实验：可能让你用Logisim之类的工具画个简单的单周期CPU数据通路图。
- 结果：你知道了概念，但依然不清楚一个真实的、哪怕是最简单的程序（比如计算1+1），其机器指令是如何被这个数据通路一步步执行的，更不用说一个复杂的图形程序了。
希伯来大学的这个项目，其革命性在于它采用了一种“自底向上、完整贯通”的实践方法。它不满足于让你“理解”分层，而是强制你“实现”每一层，并确保上下层之间能够严丝合缝地对接。
项目核心路径如下：
- 硬件层（1/2部分）：从与非门（Nand）开始，构建基本逻辑门（Not, And, Or…）、组合逻辑（ALU）、时序逻辑（DFF， 寄存器， 内存RAM），最终组装成一台具有完整指令集（Hack指令集）的计算机（Hack Computer）。
- 软件层（2/2部分，本文重点）：
- 机器码层面：为你刚构建的Hack计算机编写汇编器（Assembler），将汇编语言（Hack Assembly）翻译成机器码（16位二进制）。
- 编译层面：设计一门简易的高级语言（Jack），并为其编写编译器（Compiler），将Jack语言编译成Hack汇编语言。
- 系统层面：为Jack语言编写标准库（Operating System），提供数学运算、内存管理、字符串处理、图形输出等基础功能。
- 应用层面：用Jack语言编写一个俄罗斯方块（Tetris）游戏。
- 最终运行：游戏（Jack） -> 编译器 -> 汇编语言 -> 汇编器 -> 机器码 -> 在你的Hack计算机硬件模拟器上运行。
本文要解决的，就是带你走通这惊心动魄的第二步。你会看到，一个.jack后缀的游戏源代码文件，是如何经过你亲手（或理解）构建的工具链，变成一束束电子信号，在你构建的CPU中奔腾，最终在屏幕上渲染出下落的方块。这个过程，将彻底打通你对“计算机系统”的任督二脉。
2. 核心概念与工具链拆解
在深入实践之前，我们必须清晰定义项目2/2部分涉及的几个核心概念和工具。它们构成了从硬件到软件的桥梁。
2.1 Hack 计算机平台
这是你在项目1/2部分最终构建的“果实”。它是一台简化的、但功能完整的16位计算机。
- CPU：基于Hack指令集，能够执行算术/逻辑运算、内存访问、程序跳转等操作。
- 内存：分为指令内存（ROM）和数据内存（RAM）。ROM存放程序，RAM存放数据。
- 指令集：Hack指令集非常精简，只有两种类型的指令：
- A-指令：
@value， 用于将一個数值（或地址）加载到A寄存器。 - C-指令：
dest=comp;jump， 用于执行计算（comp），并将结果存储到目标（dest）， 同时可根据条件跳转（jump）。
- A-指令：
- 外设：通过内存映射（Memory-mapped I/O）连接了屏幕和键盘。向特定的内存地址写入数据，就能控制屏幕像素；读取特定的内存地址，就能获取键盘输入。
关键点：Hack计算机是所有上层软件的最终运行环境。你写的所有工具（汇编器、编译器）的目标，都是生成能在Hack计算机上运行的机器码。
2.2 汇编器 (Assembler)
这是软件栈的第一层。它的任务极其明确：将人类可读的Hack汇编语言（.asm文件）翻译成Hack计算机可执行的16位机器码（.hack文件）。
一个简单的Hack汇编示例：
// 计算 RAM[1] = 1 + 2 @1 D=A // D = 1 @2 D=D+A // D = D + 2 @R1 M=D // RAM[1] = D (即3)汇编器会逐行解析这个文本文件：
- 处理符号（如
@R1，需要知道R1对应的物理地址是1）。 - 将A-指令（
@xxx）翻译成二进制：0xxx（最高位为0）。 - 将C-指令（
dest=comp;jump）翻译成二进制：111accccccdddjjj（最高三位为111）。 - 输出一个每行16位二进制的
.hack文件。
实现难点：主要在于符号解析（Label和Variable）。你需要维护一个符号表（Symbol Table），在第一次遍历（第一趟）时记录所有标签（如(LOOP)）的地址，在第二次遍历（第二趟）时替换所有符号引用。
2.3 Jack 高级语言与编译器 (Compiler)
这是项目最精彩也最具挑战的部分。Jack是一门专门为教学设计的、面向对象的简易高级语言，语法类似Java/C#的简化版。
一个简单的Jack类示例：
class Main { function void main() { var int a, b, c; let a = 5; let b = 10; let c = Math.multiply(a, b); // 调用标准库函数 do Output.printString("The result is: "); do Output.printInt(c); return; } }编译器的任务是将这样的.jack源代码文件，编译成Hack汇编语言（.vm文件， 实际上是项目定义的一种虚拟机语言，但最终目标仍是汇编）。这个过程通常分为多个阶段：
- 词法分析：将源代码字符流分解成有意义的词素（Tokens），如关键字
class、标识符Main、符号{等。 - 语法分析：根据Jack语言的语法规则，将Token序列构建成语法树（Parse Tree）或抽象语法树（AST）。这验证了程序结构是否正确。
- 语义分析与代码生成：遍历AST，结合符号表（记录变量、类、方法等信息），生成等价的虚拟机代码（VM Code）或直接生成汇编代码。这涉及到：
- 表达式求值：处理运算符优先级。
- 控制流翻译：将
if、while语句翻译成带标签和跳转的汇编代码。 - 子程序调用：处理方法调用时的参数传递、返回地址保存、栈帧管理（这是核心难点！）。
- 对象管理：处理
new（内存分配）、方法调度（this指针）等。
关键洞察：编写这个编译器，会让你深刻理解“高级语言的糖衣”下面到底是什么。你会明白，一个简单的let a = b + c;语句，底层对应了多少条取数、运算、存数的机器指令，以及这些操作是如何通过栈来协调的。
2.4 虚拟机与标准库 (VM & OS)
为了简化编译器的设计，项目引入了一个中间层：Hack虚拟机。编译器的目标不是直接生成汇编，而是生成虚拟机语言（VM Code）。然后，由一个虚拟机翻译器（VM Translator）将VM Code翻译成Hack汇编。
虚拟机的作用：
- 提供抽象：让编译器不必直接处理底层硬件细节（如具体的内存地址、寄存器分配），只需操作一个统一的、基于栈的虚拟机。
- 标准化运行时：统一函数调用约定、内存分段（静态、局部、参数、this、that等）。
- 便于移植：理论上，为不同硬件写不同的VM Translator，就能让Jack程序运行在不同的机器上。
标准库（Jack OS）则是用Jack语言本身编写的一系列基础类库，提供了数学函数、字符串操作、数组处理、内存分配（简单版malloc）、屏幕绘制和键盘输入等核心功能。编译器本身也需要调用这些库。这意味着，你需要先编译好标准库，才能用Jack语言写程序。
2.5 工具链与工作流总结
整个从Jack源码到运行的游戏，其工具链和流程如下图所示（请在脑中构建）：
俄罗斯方块.jack (源代码) ↓ Jack编译器 (你实现) ↓ 俄罗斯方块.vm (虚拟机代码) ↓ VM翻译器 (你实现) ↓ 俄罗斯方块.asm (汇编代码) ↓ Hack汇编器 (你实现) ↓ 俄罗斯方块.hack (机器码) ↓ 加载到 Hack计算机模拟器 (项目提供/你构建) ↓ 运行！你的核心任务，就是实现这个工具链中的汇编器（Assembler）、编译器（Compiler）和VM翻译器（VM Translator）。
3. 环境准备与项目结构
项目提供了完整的模拟器、测试套件和初始框架，让你可以专注于核心逻辑的实现。
3.1 获取项目材料
课程官网或相关开源仓库（如Coursera上配套课程）提供了完整的软件套件。通常包含以下工具：
- 硬件模拟器（Hardware Simulator）：用于加载和运行你编写的HDL代码，可视化模拟Hack计算机的运行。在2/2部分，它也用于加载和运行生成的
.hack机器码文件。 - CPU模拟器（CPU Emulator）：一个更上层的模拟器，可以直接加载
.hack或.asm文件，并模拟计算机执行，方便调试。 - 汇编器（Assembler）：你需要实现它。项目会提供一个框架或要求你从零开始。
- 虚拟机翻译器（VM Translator）：你需要实现它。
- Jack编译器（Jack Compiler）：你需要实现它。项目通常会提供一个语法分析器框架。
- 操作系统（Jack OS）：用Jack写好的标准库（
.jack文件）。 - 测试脚本与用例：大量的
.asm，.vm，.jack测试文件，用于验证你实现的工具是否正确。
3.2 开发语言选择
项目不限制你实现这些工具所使用的编程语言。你可以用任何你熟悉的语言：Python、Java、C++、JavaScript等。选择一门你擅长、且能快速进行文本处理和数据结构操作的语言，将大大提高效率。
推荐选择：
- Python：语法简洁，字符串处理和文件操作方便，适合快速原型开发。对于理解算法和逻辑是绝佳选择。
- Java/C#：强类型，面向对象，适合构建结构更严谨的编译器前端（词法、语法分析）。
- C++：性能高，但对初学者来说实现细节可能更繁琐。
本文的示例代码将主要使用Python，因其清晰易懂。
3.3 项目目录结构建议
建立一个清晰的工作目录，例如：
nand2tetris/ ├── projects/ │ ├── 04/ # 汇编器项目 │ │ ├── source/ # 你的汇编器源代码 (e.g., assembler.py) │ │ ├── test/ # 测试用例 .asm 文件 │ │ └── output/ # 生成的 .hack 文件 │ ├── 07/ # 虚拟机翻译器项目 │ ├── 08/ # 虚拟机翻译器项目（续） │ ├── 10/ # 编译器项目（词法分析） │ ├── 11/ # 编译器项目（语法分析） │ └── 12/ # 编译器项目（代码生成） ├── tools/ # 课程提供的工具（模拟器等） └── os/ # Jack 操作系统源码4. 实战一：实现 Hack 汇编器
汇编器是三个工具中最简单的一个，是热身项目。它不涉及复杂的语法树，核心是文本处理和查表。
4.1 汇编器设计思路
一个两趟扫描（Two-pass Assembler）的汇编器是标准实现：
- 第一趟（Pass One）：遍历汇编源代码，构建符号表（Symbol Table）。只关注
(LABEL)这样的标签定义，并将其对应的指令内存地址（即当前指令的地址）记录到符号表中。伪指令（如@i）中的变量符号暂时不处理（除非是预定义符号如@R0）。 - 第二趟（Pass Two）：再次遍历源代码，生成机器码。
- 遇到
@symbol（A-指令）：- 如果
symbol是数字（如@123），直接转换为16位二进制。 - 如果
symbol是预定义符号（如@R0，@SCREEN），从预定义符号表中查找其值。 - 如果
symbol是标签（如@LOOP），从第一趟构建的符号表中查找其地址。 - 如果
symbol是未定义的变量（如@sum），则将其分配一个新的内存地址（从16开始），并记录到符号表，然后转换。
- 如果
- 遇到
dest=comp;jump（C-指令）：根据固定的码表，将dest，comp，jump各部分翻译成对应的二进制位。
- 遇到
4.2 Python 实现核心代码示例
以下是一个高度简化的汇编器核心框架，展示了关键数据结构与流程。
# assembler.py import sys import re class Assembler: def __init__(self): # 预定义符号表 self.symbol_table = { 'SP': 0, 'LCL': 1, 'ARG': 2, 'THIS': 3, 'THAT': 4, 'R0': 0, 'R1': 1, 'R2': 2, 'R3': 3, 'R4': 4, 'R5': 5, 'R6': 6, 'R7': 7, 'R8': 8, 'R9': 9, 'R10': 10, 'R11': 11, 'R12': 12, 'R13': 13, 'R14': 14, 'R15': 15, 'SCREEN': 16384, 'KBD': 24576 } self.next_variable_addr = 16 # 变量从地址16开始分配 # C-指令码表 self.comp_table = { '0': '0101010', '1': '0111111', '-1': '0111010', 'D': '0001100', 'A': '0110000', '!D': '0001101', '!A': '0110001', '-D': '0001111', '-A': '0110011', 'D+1': '0011111', 'A+1': '0110111', 'D-1': '0001110', 'A-1': '0110010', 'D+A': '0000010', 'D-A': '0010011', 'A-D': '0000111', 'D&A': '0000000', 'D|A': '0010101', # ... 还有M相关的组合，此处省略 } self.dest_table = {'': '000', 'M': '001', 'D': '010', 'MD': '011', 'A': '100', 'AM': '101', 'AD': '110', 'AMD': '111'} self.jump_table = {'': '000', 'JGT': '001', 'JEQ': '010', 'JGE': '011', 'JLT': '100', 'JNE': '101', 'JLE': '110', 'JMP': '111'} def first_pass(self, lines): """第一趟：构建符号表（只处理标签）""" rom_address = 0 for line in lines: line = self._clean_line(line) if not line: continue # 检查是否是标签定义，例如 (LOOP) label_match = re.match(r'\(([^)]+)\)', line) if label_match: label = label_match.group(1) self.symbol_table[label] = rom_address # 标签地址是下一条指令的地址 # 标签行不占用ROM地址 continue # 如果不是标签，则是一条指令，ROM地址增加 rom_address += 1 def second_pass(self, lines): """第二趟：生成机器码""" machine_code = [] for line in lines: line = self._clean_line(line) if not line or line.startswith('('): # 跳过空行和标签行 continue # 处理 A-指令 @value if line.startswith('@'): symbol = line[1:] value = self._parse_a_instruction(symbol) # 转换为16位二进制，最高位为0 binary = f'0{value:015b}' machine_code.append(binary) # 处理 C-指令 dest=comp;jump else: binary = self._parse_c_instruction(line) machine_code.append(binary) return machine_code def _clean_line(self, line): """移除注释和空白字符""" line = line.split('//')[0].strip() # 移除行内注释 return line def _parse_a_instruction(self, symbol): """解析A-指令中的符号，返回其数值""" # 如果是纯数字 if symbol.isdigit(): return int(symbol) # 如果已在符号表中（预定义符号、标签或已分配变量） if symbol in self.symbol_table: return self.symbol_table[symbol] # 否则是新的变量，分配地址并记录 else: addr = self.next_variable_addr self.symbol_table[symbol] = addr self.next_variable_addr += 1 return addr def _parse_c_instruction(self, line): """解析C-指令，返回16位二进制码""" # 分割 dest, comp, jump dest = '' comp = '' jump = '' if '=' in line: dest, rest = line.split('=') line = rest if ';' in line: comp, jump = line.split(';') else: comp = line jump = '' # 查表获取二进制码 comp_bits = self.comp_table.get(comp) dest_bits = self.dest_table.get(dest, '000') jump_bits = self.jump_table.get(jump, '000') if comp_bits is None: raise ValueError(f'Invalid comp field: {comp}') # C-指令格式：111 a c1 c2 c3 c4 c5 c6 d1 d2 d3 j1 j2 j3 return f'111{comp_bits}{dest_bits}{jump_bits}' def main(): if len(sys.argv) != 2: print("Usage: python assembler.py <input.asm>") sys.exit(1) input_file = sys.argv[1] output_file = input_file.replace('.asm', '.hack') with open(input_file, 'r') as f: lines = f.readlines() assembler = Assembler() assembler.first_pass(lines) # 第一趟 machine_code = assembler.second_pass(lines) # 第二趟 with open(output_file, 'w') as f: for code in machine_code: f.write(code + '\n') print(f"Assembly successful. Output written to {output_file}") if __name__ == '__main__': main()4.3 运行与验证
- 准备测试用例：使用项目提供的
Add.asm、Max.asm等测试文件。 - 运行汇编器：
python assembler.py projects/04/test/Add.asm - 验证输出：使用课程提供的CPU模拟器加载生成的
Add.hack文件，运行并观察结果是否正确。也可以与课程提供的标准Add.hack文件进行逐行对比。
5. 实战二：实现虚拟机翻译器 (VM Translator)
VM Translator 是连接高级语言编译器和底层汇编的桥梁。它接收.vm文件（虚拟机代码），输出.asm文件（Hack汇编代码）。
5.1 VM 代码与堆栈机模型
Hack虚拟机是一个堆栈机。所有操作都围绕一个栈（Stack）进行。算术命令（如add，sub）从栈顶弹出两个操作数，计算结果再压入栈顶。内存访问命令（如push local 2，pop argument 1）则在虚拟内存段（local， argument， this， that， static， temp， pointer， constant）和栈之间传输数据。
核心任务：将每条VM命令翻译成一系列实现其语义的Hack汇编指令。这需要你深刻理解栈指针（SP）、内存段基址指针（如LCL， ARG）是如何在Hack计算机的内存中实现的。
5.2 翻译push local i的示例
push local i命令的含义是：将local段的第i个位置的值，压入栈顶。
翻译思路（汇编伪代码）：
- 计算源地址：
addr = LCL + i。LCL寄存器存储了local段在RAM中的基地址。 - 获取该地址的值：
D = RAM[addr]。 - 将值压栈：
*SP = D; SP++。（SP寄存器指向栈顶的下一个空位）
对应的Hack汇编代码实现：
// push local i @i D=A // D = i @LCL A=D+M // A = LCL + i (计算源地址) D=M // D = RAM[LCL + i] (获取值) @SP A=M // A = SP (当前栈顶地址) M=D // RAM[SP] = D (值存入栈顶) @SP M=M+1 // SP++ (栈顶上移)pop命令的逻辑类似，但方向相反，且需要小心处理地址计算。
5.3 函数调用与返回的翻译
这是VM Translator最复杂的部分，涉及调用栈的管理。关键命令是call functionName nArgs和return。
call需要：- 将返回地址压栈。
- 保存调用者的状态（LCL， ARG， THIS， THAT）。
- 为被调用函数设置新的ARG和LCL指针。
- 跳转到函数入口。
return需要：- 将返回值保存在一个临时位置。
- 恢复调用者的状态（THAT， THIS， ARG， LCL）。
- 跳转到返回地址。
- 回收被调用函数的栈帧。
实现这部分，会让你对函数调用约定（Calling Convention）和栈帧（Stack Frame）有刻骨铭心的理解。
6. 实战三：实现 Jack 编译器
这是项目的巅峰挑战。一个完整的编译器通常分为前端（Front-end）和后端（Back-end）。项目通常将其分解为多个子项目。
6.1 编译器前端：词法分析与语法分析
词法分析器（Tokenizer/Scanner）：将Jack源代码字符流转换为Token流。
# tokenizer.py 示例片段 import re class Tokenizer: KEYWORDS = ['class', 'constructor', 'function', 'method', 'field', 'static', 'var', 'int', 'char', 'boolean', 'void', 'true', 'false', 'null', 'this', 'let', 'do', 'if', 'else', 'while', 'return'] SYMBOLS = r'{}()[].,;+-*/&|<>=~' def __init__(self, input_file): with open(input_file, 'r') as f: self.source = f.read() self._clean_comments() self.tokens = [] self.current_pos = 0 def _clean_comments(self): # 移除 /* */ 注释和 // 注释 pattern = r'/\*.*?\*/|//.*?$' self.source = re.sub(pattern, '', self.source, flags=re.MULTILINE | re.DOTALL) def advance(self): """获取下一个Token""" if self.current_pos >= len(self.source): return None # 跳过空白 # ... 识别关键字、标识符、符号、整数常量、字符串常量 ... # 将识别出的Token类型和值存入 self.tokens语法分析器（Parser）：根据Jack语法规则，将Token流组织成语法树。项目通常会提供一个语法规则文件（.g4或类似）或明确的语法描述。你需要实现递归下降（Recursive Descent）或使用分析器生成工具（如ANTLR）。
核心是编写一系列parseXXX()方法，如parseClass()，parseClassVarDec()，parseSubroutine()，parseStatements()，parseExpression()等，它们相互递归调用，构建出树形结构。
6.2 编译器后端：语义分析与代码生成
在语法树的基础上，你需要：
- 构建符号表（Symbol Table）：遍历语法树，记录每个类（Class）、子程序（Subroutine）中的变量（field， static， local， parameter）的名称、类型、种类（kind）和作用域。
- 生成虚拟机代码（VM Code）：再次遍历语法树，结合符号表，为每个语法结构生成对应的VM命令序列。
let语句：计算右侧表达式（结果在栈顶），然后弹出并存储到左侧变量对应的内存段位置。if和while语句：生成条件判断和跳转标签。- 表达式求值：处理运算符优先级，生成对应的算术/逻辑VM命令（
add，sub，and，or，not，eq，gt，lt）。 - 子程序调用：处理
do和return语句，生成call和return的VM命令。
6.3 一个简单的代码生成示例：let语句
假设有Jack语句：let x = y + 5;， 其中x和y是局部变量（local）。生成VM代码的思路：
- 计算表达式
y + 5的值，并压入栈顶。push local y_index// 将y的值压栈push constant 5// 将常数5压栈add// 弹出栈顶两个数相加，结果压栈
- 将栈顶结果弹出，存入变量
x。pop local x_index// 弹出栈顶值，存入x
最终生成的VM代码可能如下：
push local 1 // 假设y是局部变量索引1 push constant 5 add pop local 0 // 假设x是局部变量索引07. 整合与运行：从 Jack 到俄罗斯方块
当你成功实现了汇编器、VM翻译器和Jack编译器后，就可以启动完整的工具链，编译并运行俄罗斯方块游戏了。
7.1 编译 Jack 操作系统 (OS)
首先，你需要编译Jack语言的标准库（OS）。
# 假设你的编译器叫 JackCompiler.py python JackCompiler.py os/这会在os/目录下为每个.jack文件（如Math.jack，Memory.jack）生成对应的.vm文件。
7.2 编译俄罗斯方块游戏
然后，编译你的游戏源代码。
python JackCompiler.py projects/12/Tetris/这会为Tetris.jack等文件生成.vm文件。
7.3 使用 VM 翻译器整合所有 VM 文件
VM翻译器需要处理一个目录下的所有.vm文件，并将它们整合输出为一个.asm文件。这模拟了“链接（Linking）”的过程。
python VMTranslator.py projects/12/Tetris/这会生成一个Tetris.asm文件，其中包含了游戏和所有被调用的OS功能的汇编代码。
7.4 使用汇编器生成机器码
最后，使用你实现的汇编器，将汇编代码转为机器码。
python assembler.py projects/12/Tetris/Tetris.asm生成最终的Tetris.hack文件。
7.5 在模拟器中加载并运行
打开课程提供的硬件模拟器或CPU模拟器。
- 加载
Tetris.hack文件到ROM。 - 加载
Tetris.tst测试脚本（如果有）。 - 点击“运行（Run）”。
- 如果一切正确，你将看到模拟器的屏幕区域开始绘制俄罗斯方块的游戏界面，并且可以通过模拟键盘进行控制！
这一刻的成就感是无与伦比的。你从最底层的逻辑门开始，构建了CPU和计算机，又为它打造了完整的软件工具链，最终让一个由高级语言编写的复杂游戏，在你亲手构建的“机器”上跑了起来。这完美诠释了“计算机系统”的完整图景。
8. 常见问题与调试心得
在这个漫长的构建过程中，你一定会遇到无数bug。以下是一些常见陷阱和调试建议：
| 问题现象 | 可能原因 | 排查方式 | 解决方案 |
|---|---|---|---|
| 汇编器生成的.hack文件与标准输出不同 | 1. 符号解析错误（标签或变量地址算错）。 2. C-指令翻译码表错误。 3. 未处理注释和空行。 | 1. 使用diff工具逐行对比。2. 打印第一趟后的符号表，检查标签地址。 3. 单步调试A-指令和C-指令的解析函数。 | 1. 仔细检查符号表插入和查找逻辑。 2. 核对Hack指令集规范，确保码表完全正确。 3. 加强预处理，确保行清理干净。 |
| VM Translator 生成的程序运行结果错误 | 1. 栈指针（SP）操作错误（如push后未递增）。 2. 内存段地址计算错误（特别是LCL， ARG等指针）。 3. 函数调用/返回逻辑错误，导致栈帧混乱。 | 1. 使用CPU模拟器单步执行生成的汇编代码，观察SP和关键内存地址（如RAM[0]）的变化。 2. 编写最小的VM测试文件（如只做一次push/pop）。 3. 重点调试 call和return生成的汇编块。 | 1. 画图！画出每个命令执行前后栈和内存的状态。 2. 严格遵循项目文档中关于内存映射和调用约定的描述。 3. 将复杂的 call/return逻辑封装成函数，并单独测试。 |
| Jack 编译器编译后程序无法运行，或行为异常 | 1. 符号表未正确构建（变量类型/种类错误）。 2. 表达式求值顺序或运算符优先级错误。 3. 对象方法调用时 this指针处理错误。4. 生成的VM命令序列逻辑错误。 | 1. 编译一个非常简单的Jack程序（如只有一个Main类和一个加法），与标准编译器输出对比。 2. 大量使用 print语句，输出编译器每个阶段的中间结果（Token， 语法树节点，符号表内容，生成的VM代码）。3. 利用项目提供的“对比测试”工具。 | 1.增量开发。先实现能编译不包含数组、对象、复杂表达式的程序。 2.单元测试。为Tokenizer， Parser， CodeWriter分别编写小测试。 3.理解语义。不要只机械实现语法，要理解每条Jack语句对应的VM代码应该做什么。 |
| 最终游戏画面错乱或无法控制 | 1. 屏幕内存映射（从RAM[16384]开始）写入错误。 2. 键盘内存映射（RAM[24576]）读取错误。 3. 游戏逻辑本身的Jack代码有误（如果你的游戏是自己写的）。 | 1. 检查编译器/VM Translator生成的与屏幕/键盘交互的代码。 2. 在CPU模拟器中运行，手动修改RAM[24576]的值模拟按键，看程序是否响应。 3. 使用课程提供的标准 Tetris游戏进行测试，以排除游戏逻辑问题。 | 1. 确保对Screen和Keyboard类的Jack OS调用被正确编译和链接。2. 回顾Hack计算机的I/O内存映射规范。 |
最重要的调试建议：从简单到复杂，逐层验证。不要试图一次性写完整个编译器然后调试。先确保你的汇编器能通过所有测试，再确保VM Translator能通过所有测试，最后才挑战编译器。在编译器内部，也先实现词法分析，通过测试；再实现语法分析解析类定义，通过测试；逐步增加功能。
9. 最佳实践与工程启示
完成这个项目，你收获的远不止是几个工具的实现。它带给你的工程思维和系统视角是无价的。
- 分层抽象是计算机科学的基石：从晶体管到逻辑门，到ALU/寄存器，到CPU/内存，到指令集，到汇编器/虚拟机，到编译器/操作系统，再到应用程序。每一层都建立在下一层的可靠实现之上，并为上一层提供更简洁的接口。理解并实践这种分层，是成为优秀工程师的关键。
- 接口与实现分离：Hack计算机的硬件规范（指令集、内存映射）就是软件层的“接口”。只要遵循这个接口，任何语言、任何编译器都可以在上面运行。这种契约精神在大型软件系统中至关重要。
- 测试驱动开发（TDD）：项目提供了极其完善的测试套件。你应该始终让测试通过作为一个小目标。写一点代码，就跑一下测试，快速反馈。这是保证复杂系统正确性的最有效方法。
- 工具链的威力：一个完整的开发环境离不开强大的工具链（编译器、汇编器、链接器、调试器）。亲手打造一次，你会对这些日常使用的工具有全新的、更深层次的理解和敬畏。
- 理论到实践的闭环：这个项目强迫你将《计算机组成原理》、《编译原理》、《操作系统》等多门课程的理论知识串联起来，形成一个完整的、可运行的闭环。这种“知其然并知其所以然”的体验，是任何单一课程都无法提供的。
当你看到自己构建的计算机成功运行起俄罗斯方块时，回望这条从Nand门开始的漫长道路，你会真正理解那句名言：“What I cannot create, I do not understand.”（我不能创造的，我便无法真正理解。）——理查德·费曼。
这不仅仅是一个课程项目，这是一次通往计算机科学核心的朝圣之旅。建议你预留充足的时间（数十到上百小时），耐心地、一步一个脚印地去完成它。每通过一个测试，每解决一个bug，你对计算机系统的理解就会加深一分。最终，当你通关之时，你眼中的软件世界，将从此不同。
