用Python手写PL0编译器：从虚拟机到递归下降完整实战

简介这是南京航空航天大学编译原理课程设计PL0编译器的Python实现面向计算机专业学生或需完成类似课设的开发者。资源围绕PL0教学语言通过Python从零实现编译前端词法分析、语法分析、语义分析并延伸至后端代码生成覆盖了编译器构建的主要环节。包内5个Python脚本分别对应词法分析器、语法分析、语义分析、语义分析测试版本及后端模块另附Markdown说明、文本资料和编译原理课设报告doc文档共8个文件压缩包仅792KB结构清晰便于按模块对照学习。已有181人学习下载尤其适合正在学习编译原理、准备编译器课程设计或希望系统梳理前端到后端流程的学生使用。通过这份资源读者可以掌握递归下降分析、抽象语法树构建、中间代码生成等关键环节并借助测试版本与报告加深理解快速复现完整课设。1. 用Python重写PL0课设为什么说这是最划算的编译原理实践编译原理课设选PL0几乎是国内计算机专业绕不开的坎。南京航空航天大学的这套题要求用高级语言实现PL0编译器而市面上能找到的参考实现大多是C或Pascal指针、静态链、动态链来回折腾跑起来动不动就段错误改一行重新编译半分钟。用Python重写一遍词法、语法、符号表、虚拟机每一层都能单独调试整个课设周期内你能看清楚每一层到底发生了什么理解的深度完全不一样。这篇文章按我实际做完并验收通过的路径来讲虚拟机怎么搭、词法分析怎么写、递归下降怎么调、答辩前有哪些坑必须提前踩一遍。新手能照着把整个项目跑通已经写完还没验收的人也能对照检查自己的实现有没有埋雷。2. PL0的语言骨架与P-CODE虚拟机先定翻译目标再动手写代码很多同学拿到题目第一件事是写词法分析写到一半发现单词变成token之后怎么办完全没想清楚又回头改结构。我一般建议反过来先把目标机定下来。PL0有两条实现路线一条是直接对语法树求值另一条是先把源程序编译成P-CODE再写一个虚拟机去执行。前者代码量小适合时间紧的要求后者更贴合教材里编译两个字的完整含义答辩时从源程序一路讲到目标代码再讲到栈帧整条链路非常清楚。NUAA课设的标准做法是后者这一章先把P-CODE的骨架立住后面所有代码都往这个目标上靠。2.1 PL0语法子集一张表看清全部语法成分PL0的语法原始定义来自Wirth的《Algorithms Data Structures Programs》国内教材基本沿用很多学校的编译原理实验和课设题目就是它。整个语言的语法子集非常小全部列出来不超过20条产生式语法成分定义对应递归函数程序分程序 .program分程序[常量声明][变量声明][过程声明] 语句block常量声明CONST 标识符数字 {,标识符数字} ;const_declaration变量声明VAR 标识符 {,标识符} ;var_declaration过程声明PROCEDURE 标识符 ; 分程序 ; {...}procedure_declaration语句赋值 / 调用 / 复合 / 条件 / 循环 / 读 / 写statement条件ODD 表达式表达式 关系运算符 表达式表达式[-] 项 {(加项因子 {(乘除) 因子}因子标识符数字这套语法覆盖了编译原理几乎全部核心问题词法识别、递归下降、运算符优先级通过expression/term/factor三层嵌套体现、过程嵌套作用域、跳转指令回填。注意PL0没有for循环、没有数组、没有布尔表达式你别自己乱加功能——课设评分一般先看教材范围内的正确性加花活的前提是基础功能全对否则答辩时老师顺着你自定义的语法多问两句暴露的风险大于加分。2.2 选型手写递归下降别折腾自动生成器用Python做课设实现路线有三条。第一条是手写递归下降一个语法成分对应一个函数代码结构就是语法结构报错时Python的调用栈直接告诉你卡在哪个语法函数里。第二条是用PLY或ANTLR这类生成器但你得先理解LALR或LL理论课设周期内光调冲突可能就耗掉一周而且生成的parser是个黑匣子答辩时老师翻开你的代码问递归下降在哪你很难讲清楚。第三条用lark这种高层库更不推荐那是给生产环境用的玩具对课设没有任何教学收益。我给出的选型是手写递归下降配合手写虚拟机全程只用Python标准库。这样做的好处是零依赖机房机器上Python安装版本五花八门vscode python环境配置不全的情况很常见纯标准库在Python 3.8以上都能直接跑不会因为装不上第三方包而在演示当场翻车。2.3 P-CODE指令表十几条指令撑起一个虚拟机PL0经典的中间代码叫P-CODE指令集非常精简全部列出来就这些指令操作数语义LIT0, a把常量a压栈OPR0, a算术/比较/IO运算a是运算编号LODl, a把层差l、偏移a的变量值压栈STOl, a把栈顶值写入层差l、偏移a的变量CALl, a调用层差为l、入口地址为a的过程INT0, a栈指针加a为局部变量腾空间JMP0, a无条件跳转到aJPC0, a栈顶为0时跳转到a否则栈顶出栈OPR的运算编号需要单独记表0返回1取负2加法3减法4乘法5整除6奇偶判断8相等9不等10小于11小于等于12大于13大于等于14读入15写出。注意编号7是个空档在经典教材里不存在你写的时候别自作主张填东西。层差l是整个P-CODE里最容易写错的地方。它表示当前所在过程层号减去变量定义所在过程层号比如主程序是第0层过程p是第1层那么p内部访问主程序的变量时l就是1而访问p自己定义的变量时l是0。LOD和STO指令寻址时靠这个l沿着静态链向上跳跳错了就去别的活动记录里取数属于典型的查不出原因的玄学bug。2.4 虚拟机主循环一份能直接跑的Python骨架虚拟机这部分我直接给出能跑的骨架注意栈的布局设计# vm.py —— P-CODE虚拟机 class Ins: __slots__ (op, lev, arg, line) def __init__(self, op, lev, arg, line0): self.op op # LIT/OPR/LOD/STO/CAL/INT/JMP/JPC self.lev lev # 层差LOD/STO/CAL使用 self.arg arg # 常量值、偏移量或跳转地址 self.line line # 源程序行号排错用 class VM: LEV 0 # 活动记录中静态链的位置 DYN 1 # 活动记录中动态链的位置 RET 2 # 活动记录中返回地址的位置 def __init__(self, code, stack_size4096): self.code code self.s [0] * stack_size self.sp -1 # 栈顶指针 self.bp 0 # 基址指针指向当前活动记录起点 self.pc 0 # 程序计数器 self.halt False def run(self): while not self.halt: ins self.code[self.pc] self.pc 1 if ins.op LIT: self.sp 1 self.s[self.sp] ins.arg elif ins.op INT: self.sp ins.arg # 栈顶抬高分配局部空间 elif ins.op LOD: frame self.base(ins.lev) self.sp 1 self.s[self.sp] self.s[frame ins.arg] elif ins.op STO: frame self.base(ins.lev) self.s[frame ins.arg] self.s[self.sp] self.sp - 1 elif ins.op CAL: self.call(ins) elif ins.op JMP: self.pc ins.arg elif ins.op JPC: # 条件跳转栈顶为0才跳 if self.s[self.sp] 0: self.pc ins.arg self.sp - 1 elif ins.op OPR: self.opr(ins.arg) else: raise RuntimeError(f未知指令 {ins.op} pc{self.pc-1}) def base(self, lev): 沿静态链向上找第lev层活动记录的基址 frame self.bp while lev 0: frame self.s[frame self.LEV] lev - 1 return frame def call(self, ins): # 从当前帧往上找lev层得到被调过程的静态链 self.s[self.sp 1] self.base(ins.lev) # 存静态链 self.s[self.sp 2] self.bp # 存动态链 self.s[self.sp 3] self.pc # 存返回地址 self.bp self.sp 1 # 新活动记录起点 self.sp self.bp 3 # 局部变量从bp3开始 self.pc ins.arg def opr(self, a): if a 0: # 返回 self.sp self.bp - 1 self.pc self.s[self.bp self.RET] self.bp self.s[self.bp self.DYN] self.halt self.sp 0 elif a 1: self.s[self.sp] -self.s[self.sp] # 取负 elif a 2: self.s[self.sp-1] self.s[self.sp]; self.sp - 1 # 加 elif a 3: self.s[self.sp-1] - self.s[self.sp]; self.sp - 1 # 减 elif a 4: self.s[self.sp-1] * self.s[self.sp]; self.sp - 1 # 乘 elif a 5: # 整除 self.s[self.sp-1] // self.s[self.sp]; self.sp - 1 elif a 6: self.s[self.sp] self.s[self.sp] % 2 # 奇偶 elif a 8: self.s[self.sp-1] int(self.s[self.sp-1] self.s[self.sp]); self.sp - 1 elif a 9: self.s[self.sp-1] int(self.s[self.sp-1] ! self.s[self.sp]); self.sp - 1 elif a 10: self.s[self.sp-1] int(self.s[self.sp-1] self.s[self.sp]); self.sp - 1 elif a 11: self.s[self.sp-1] int(self.s[self.sp-1] self.s[self.sp]); self.sp - 1 elif a 12: self.s[self.sp-1] int(self.s[self.sp-1] self.s[self.sp]); self.sp - 1 elif a 13: self.s[self.sp-1] int(self.s[self.sp-1] self.s[self.sp]); self.sp - 1 elif a 14: # 读入 self.sp 1 self.s[self.sp] int(input()) elif a 15: # 写出 print(self.s[self.sp]) self.sp - 1调通这个骨架的标志是你手写一段P-CODE比如LIT 0 3、LIT 0 5、OPR 0 2、OPR 0 15跑出数字8。先验证虚拟机本身没问题再往后写词法和语法出了问题就能确定不在虚拟机这一层。看几个关键点。base函数是整个寻址的核心它从bp出发把每个活动记录第0个槽位的值取出来当作上一层的基址循环lev次就找到了目标层。这就是静态链的物理含义——兄弟过程之间互相找不到只有定义嵌套的外层过程才在链条上。call指令的布局要记住新活动记录的前三个槽位依次是静态链、动态链、返回地址局部变量从bp3开始挤。所以生成代码时主程序第一个变量的偏移量要从3开始算这就是为什么符号表里记录offset要从3起步而不是从0开始。很多学生在里栽跟头偏移写0直接把活动记录的静态链槽位覆盖了程序跑着跑着就跳到莫名其妙的内存上。这一章把翻译目标立住了。接下来写词法分析把源文件变成语法分析器能吃的token流。3. 词法分析从字符流到token流十几行核心逻辑搞定词法分析是整个课设里最简单的一层但最简单的部分最容易翻车——不是写不出来而是写复杂了。我看到不少同学上来就引入re正则库把运算符、标识符、数字全部用正则匹配结果边界情况比手写还多。PL0的保留字就13个手写一个状态循环完全够用而且答辩时你的词法怎么识别数字这种问题你只需指着一行代码说这里连续读数字字符直到非数字为止比解释正则表达式直观得多。3.1 token的类型与保留字先定义清楚再写代码我一般用数字作为token类型1标识符、2数字、3保留字、4运算符/分隔符、5结束符。保留字单独用一个字典映射这样const是不是标识符的判断就是一个字典查询的事。# lexer.py —— 保留字表 KEYWORDS { begin: 1, end: 2, if: 3, then: 4, while: 5, do: 6, const: 7, var: 8, procedure: 9, call: 10, read: 11, write: 12, odd: 13, } class Token: __slots__ (type, value, line, col) def __init__(self, type_, value, line, col): self.type type_ self.value value self.line line self.col col这里有个约定要注意保留字虽然用了KEYWORDS字典做映射但token的type要么是3保留字要么是1标识符value都存单词本身。语法分析器判断当前是不是if时看的是token.type 3 and token.value if而不是靠字典里的数字——字典里的数字只是区分哪些词是保留字的标记真正的语义判断走value字符串这样代码可读性好很多。3.2 核心循环跳过空白、识别单词和数字词法分析的主体就一个next_token方法每次调用返回下一个token。核心逻辑就三种情况空白跳过、字母开头走标识符/保留字分支、数字开头走数字分支。# lexer.py —— 词法分析核心循环 class Lexer: def __init__(self, text): self.text text self.pos 0 self.line 1 self.col 1 def next_token(self): while self.pos len(self.text): ch self.text[self.pos] if ch in \t: self._advance() # 空格和制表符直接跳过 elif ch \n: self._advance() self.line 1 # 换行时行号加1列号归1 self.col 1 elif ch.isalpha(): return self._read_word() # 字母开头标识符或保留字 elif ch.isdigit(): return self._read_number() # 数字开头常量 elif ch in -*/#:();,.: # 单双字符运算符 return self._read_operator() else: raise RuntimeError( f词法错误: 第{self.line}行第{self.col}列出现非法字符 {ch!r}) return Token(5, EOF, self.line, self.col) # 文件末尾 def _advance(self): self.pos 1 self.col 1 def _read_word(self): start_line, start_col self.line, self.col start self.pos while self.pos len(self.text) and self.text[self.pos].isalnum(): self._advance() word self.text[start:self.pos] if word in KEYWORDS: return Token(3, word, start_line, start_col) return Token(1, word, start_line, start_col) def _read_number(self): start_line, start_col self.line, self.col start self.pos while self.pos len(self.text) and self.text[self.pos].isdigit(): self._advance() number int(self.text[start:self.pos]) return Token(2, number, start_line, start_col)逻辑说明_read_word先读完整串字母数字再回头查字典判断是保留字还是普通标识符。这里有一个隐藏规则PL0规定标识符以字母开头后面可以跟字母或数字。如果你用ch.isalpha()判断第一个字符用ch.isalnum()判断后续字符就自动满足这个规则。反过来如果首字母判断也放开成isalnum那2x这种非法标识符会被当成数字2加标识符x词法错误检测就漏了。参数说明Token里存的line和col是token开始的位置。报错信息带行列号是课设报告里的展示点老师问你的词法错误怎么定位你直接在报错里带上行列号比只报invalid char评分观感好一个档次。列号从1开始、行号从1开始和教材里报错的习惯一致调试对得上。3.3 运算符的分支判断两个字符的优先级PL0的运算符里:赋值号和、这种是两个字符组合其余都是单字符。判断起来有技巧先看一眼当前位置加一的两个字符组合是不是已知双字符运算符是就一次吃掉不是就按单字符处理。def _read_operator(self): start_line, start_col self.line, self.col two self.text[self.pos:self.pos 2] if two in (:, , ): self._advance() self._advance() return Token(4, two, start_line, start_col) ch self.text[self.pos] self._advance() return Token(4, ch, start_line, start_col)这里的关键是双字符运算符的判断顺序一定要先取两个字符判断再退回单字符。因为当输入是:时如果你先按单字符处理:下一次再读到语法分析器会看到一个孤零零的冒号直接报语法错误。还有一种易错情况是后面跟是小于等于但后面跟数字比如3就应该是小于号加数字3上面的写法里two只有三种组合所以3会正确退回单字符分支。PL0的关系运算符只有、#、、、、这六种#是不等于。别自己加上!如果出现!_read_operator会先吞掉!然后报非法字符这个行为是符合教材的。课设阶段词法错误直接抛异常停止就好不需要错误恢复做错误恢复是加分项但前提是主流程全部稳定否则反而拖累进度。3.4 手写一个测试入口把token流打出来看看词法层写完别急着写语法分析先花五分钟验证。最直接的办法是写个测试入口把token流一行行打出来和我上课给出的样例输出对一遍# test_lexer.py —— 调试用 def main(): text const k3; var x; begin read(x); x : x k end. lexer Lexer(text) while True: tok lexer.next_token() print(tok.type, tok.value, tok.line, tok.col) if tok.type 5: # EOF break if __name__ __main__: main()跑出来应该是3 const 1 1、1 k 1 7、4 1 8、2 3 1 9等。注意:应该是一个token4 : 1 15这种输出而不是分开的冒号和等号。这里如果发现:和分开了就是3.3节的双字符判断没生效回代码查two的取值。词法层有bug后面语法分析定位问题时你会浪费大量时间在错误方向上。所以这一步的验证别省尤其是行号列号后面语法报错全靠它们。4. 递归下降语法分析一边分析一边生成P-CODE语法分析是整个课设的核心也是答辩时老师问得最多的地方。我推荐的做法是语法制导翻译递归下降的过程中每识别出一个语法成分就同步生成对应的P-CODE指令分析完整个程序目标代码也刚好生成完不需要单独再遍历一遍语法树。这样代码量小而且每一行生成指令的代码旁边就是对应的语法产生式老师顺着就能看懂。4.1 表达式三件套factor、term、expression如何体现优先级PL0没有数组没有指针表达式只有加减乘除、括号、常量、变量、取负。三层结构正好体现运算优先级factor只处理最小单元term处理乘除expression处理加减高层函数调用低层函数优先级就自然体现出来了。下面是Parser类的核心方法片段辅助方法在第4.2节补全。# parser.py —— 语法制导翻译生成P-CODE指令 class Parser: def __init__(self, lexer): self.lexer lexer self.sym lexer.next_token() # 当前token self.code [] # 生成的P-CODE self.tables [] # 符号表栈4.3小节细讲 def advance(self): self.sym self.lexer.next_token() def error(self, msg): raise RuntimeError(f第{self.sym.line}行: {msg}) def expect(self, op): if self.sym.type 4 and self.sym.value op: self.advance() else: self.error(f期望 {op}) def expect_keyword(self, word): if self.sym.type 3 and self.sym.value word: self.advance() else: self.error(f期望保留字 {word}) def expression(self): if self.sym.type 4 and self.sym.value in (, -): op self.sym.value # 一元正负号 self.advance() self.term() if op -: self.code.append(Ins(OPR, 0, 1, 0)) # 取负 else: self.term() while self.sym.type 4 and self.sym.value in (, -): op self.sym.value self.advance() self.term() self.code.append(Ins(OPR, 0, 2 if op else 3, 0)) def term(self): self.factor() while self.sym.type 4 and self.sym.value in (*, /): op self.sym.value self.advance() self.factor() self.code.append(Ins(OPR, 0, 4 if op * else 5, 0)) def factor(self): if self.sym.type 1: # 标识符 name self.sym.value lev, off self.lookup(name) # 查符号表得到层差和偏移 self.advance() self.code.append(Ins(LOD, lev, off, 0)) elif self.sym.type 2: # 数字常量 self.code.append(Ins(LIT, 0, self.sym.value, 0)) self.advance() elif self.sym.type 4 and self.sym.value (: self.advance() self.expression() self.expect()) else: self.error(因子位置遇到非法符号)生成逻辑有个顺序问题值得注意factor里读取标识符时我在advance之前就把name取到了advance之后token就变了所以查符号表要用存下来的name而不是self.sym.value。很多同学在这里写错等advance完再取value拿到的是下一个token的内容查出来全是未定义变量。一元负号的处理放在expression开头是因为PL0语法里表达式允许以正负号开头比如-x 1。生成指令的顺序是LOD x、OPR 1取负、LIT 1、OPR 2加完全符合-x 1的语义。如果一开始没处理一元符号-x会被当成非法表达式开头。4.2 语句与流程控制IF和WHILE的跳转回填语句的类型多一点但核心难点都在跳转指令的回填上。PL0没有布尔表达式条件的结果是一条比较指令结果0或1存在栈顶然后JPC根据栈顶决定是否跳转。问题在于翻译到IF语句时then分支还没生成出口地址还不知道只能先放一个占位地址等语句翻译完再把真实地址填回去。def expect_assign(self): if self.sym.type 4 and self.sym.value :: self.advance() else: self.error(期望赋值号 :) def statement(self): if self.sym.type 1: # 赋值语句 name self.sym.value self.advance() self.expect_assign() # 吃掉 : lev, off self.lookup(name) self.expression() self.code.append(Ins(STO, lev, off, 0)) elif self.sym.type 3 and self.sym.value if: self.advance() self.condition() # 生成比较指令结果在栈顶 jpc len(self.code) # 记录跳转指令的位置 self.code.append(Ins(JPC, 0, 0, 0)) # 占位地址稍后回填 self.expect_keyword(then) self.statement() # 翻译then分支 self.code[jpc].arg len(self.code) # 回填出口地址 elif self.sym.type 3 and self.sym.value while: self.advance() start len(self.code) # 循环体开始位置 self.condition() jpc len(self.code) self.code.append(Ins(JPC, 0, 0, 0)) # 条件不成立则跳出 self.expect_keyword(do) self.statement() self.code.append(Ins(JMP, 0, start, 0)) # 跳回条件判断 self.code[jpc].arg len(self.code) # 回填循环出口 elif self.sym.type 3 and self.sym.value begin: self.advance() self.statement() while self.sym.type 4 and self.sym.value ;: self.advance() self.statement() self.expect_keyword(end) elif self.sym.type 3 and self.sym.value call: self.advance() name self.sym.value lev, entry self.lookup_proc(name) self.advance() self.code.append(Ins(CAL, lev, entry, 0)) elif self.sym.type 3 and self.sym.value read: self.advance() self.expect(() name self.sym.value lev, off self.lookup(name) self.advance() self.expect()) self.code.append(Ins(OPR, 0, 14, 0)) # 读入值压栈 self.code.append(Ins(STO, lev, off, 0)) elif self.sym.type 3 and self.sym.value write: self.advance() self.expect(() self.expression() self.expect()) self.code.append(Ins(OPR, 0, 15, 0)) # 弹栈打印 else: self.error(语句起始符号非法) def condition(self): if self.sym.type 3 and self.sym.value odd: self.advance() self.expression() self.code.append(Ins(OPR, 0, 6, 0)) # 奇偶判断 else: self.expression() if self.sym.type 4 and self.sym.value in (, #, , , , ): op self.sym.value self.advance() self.expression() opr_map {: 8, #: 9, : 10, : 11, : 12, : 13} self.code.append(Ins(OPR, 0, opr_map[op], 0)) else: self.error(条件中缺少关系运算符)回填是课设答辩时老师问得最密集的考点。你要能讲清楚为什么先写0因为地址还不知道。什么时候知道then分支翻译完代码列表长度就是出口地址。所以用len(self.code)当地址再回头改jpc那个指令的arg。while循环比if多一步循环体结束后要无条件跳回条件判断的位置这个start必须放在condition之前记录否则条件那块代码会被重复生成程序直接死循环。注意read和write的括号处理。PL0教材语法里read(x)和write(表达式)都必须带括号expect(()和expect())不能省。有的参考实现偷懒不检查括号语法错乱时行为会很奇怪。4.3 符号表与作用域嵌套过程怎么找到外层变量PL0过程可以嵌套符号表要用栈管理进入一个block推入一层空表退出时弹出。查找时从当前层往外层找找到就返回层差和偏移。层差不是层号是距离这是最容易错的地方。# 符号表栈每个元素是该层所有符号的列表 def enter_block(self): self.tables.append([]) def leave_block(self): self.tables.pop() def add_var(self, name): offset 3 len([s for s in self.tables[-1] if s[1] var]) self.tables[-1].append((name, var, offset)) return offset def add_proc(self, name, entry): self.tables[-1].append((name, proc, entry)) def lookup(self, name): cur len(self.tables) - 1 # 当前层号 for lev in range(cur, -1, -1): for name_, kind, val in self.tables[lev]: if name_ name: depth cur - lev # 层差 当前层 - 定义层 if kind var: return depth, val raise RuntimeError(f{name} 是过程名不能当变量用) raise RuntimeError(f未定义标识符 {name})lookup的层差计算是整个课设里最值得写对的一行。cur是当前层号lev是找到定义的那一层两者相减才是LOD/STO指令里要用的层差。如果你返回的是lev本身那内层过程访问全局变量时用了0虚拟机就会在当前活动记录里找偏移找到的是过程自己的局部变量结果全乱。offset从3开始和虚拟机的活动记录布局对应活动记录起点bp处0保存静态链1保存动态链2保存返回地址从3开始才是局部变量区。主程序第一个变量偏移3第二个偏移4过程和主程序同样规则。这两边的数字必须一致否则编译生成的内存布局和虚拟机运行时的内存布局对不上程序直接寄。同名遮蔽是静态作用域的正确表现内层定义了一个和外层同名的变量内层里所有对这个名字的引用都指向内层那个lookup从高层往低层找先碰到内层的就停不会跑到外层。过程名和变量名不能重名否则lookup查出来类型不匹配直接报错这也符合PL0的规定。4.4 两条路线对比直接执行语法树还是生成P-CODE到这一步有的同学会问既然我要写解释器为什么不直接对AST求值何必多生成一层P-CODE两种路线都可行列个对比供你按自己课设要求选对比项AST直接执行生成P-CODE再执行代码量少80-120行需要额外写虚拟机是否符合教材相当于解释器路线完全对应Wirth原书的编译器虚拟机答辩好讲程度讲递归和求值讲目标代码、回填、活动记录内容更厚调试难度递归栈清晰出了bug要在指令级定位我的建议很直接如果课设题目明确写了编译为中间代码或P-CODE你只能走第二条路。如果只是说实现PL0两条都可以。但从答辩效果看P-CODE路线能展示的东西多一整个层次目标代码dump、虚拟机栈、活动记录三槽结构这些内容覆盖面广也容易拿高分。代价是进入第2章那个虚拟机的坑但那个坑已经在第2章填平了。5. 课设避坑指南环境、递归深度、作用域与答辩演示写PL0课设的过程80%的时间不是在写功能而是在排错。这里把我自己踩过和帮别人踩过的坑整理成五条每一条都是真实发生过、并且能让程序瞬间崩掉的级别。5.1 中文注释报UnicodeDecodeError文件编码没对上现象lexer读源文件Python直接抛UnicodeDecodeError: utf-8 codec cant decode byte 0xd3。 原因Windows记事本默认用GBK保存文件Python打开文件时默认UTF-8两边的编码表对不上。字节0xd3在GBK里是中字的一部分在UTF-8里是非法序列。 解决统一用UTF-8保存源文件并且代码里显式指定编码。注意开头有UTF-8 BOM的情况要用utf-8-sig吸收掉with open(path, r, encodingutf-8-sig) as f: text f.read()判断方法在VSCode右下角看文件编码如果显示GBK点一下改成UTF-8重存。这个坑藏得很深的原因是中文Windows下双击运行控制台程序可能正常但一旦在VSCode的Python环境里跑默认编码就变了。5.2 RecursionError递归下降真的会递归爆栈现象写了一个嵌套20层的表达式((((...1...))))一跑直接崩报错RecursionError。 原因递归下降每个括号、每个运算符都往下递归一层Python默认递归上限1000嵌套深一点就爆。这不是死循环是合法的深嵌套程序。 解决入口处把递归上限调高10000对PL0这种小语言绰绰有余import sys sys.setrecursionlimit(10000)注意不要调成sys.setrecursionlimit(10**9)这种天文数字真遇到无限递归时Python进程会直接内存爆掉比报错还难收拾。5.3 内层过程修改全局变量无效层差写反了现象主程序里x10过程p里有x : x 1调用p之后再打印x还是10。 原因STO指令的lev参数用了定义层号而不是层差。p是第1层x定义在第0层层差应该是1但代码里写成了0于是STO把结果写到了p自己的活动记录里而不是主程序的x位置。 解决在lookup里加临时调试输出逐个核对def lookup(self, name): cur len(self.tables) - 1 for lev in range(cur, -1, -1): for sym in self.tables[lev]: if sym[0] name: depth cur - lev print(f[debug] {name}: cur{cur} lev{lev} depth{depth}) return depth, sym[2]输出里如果看到depth不是预期值马上能发现问题。这个bug难查的原因是它不是运行时崩溃而是逻辑错程序能跑完但结果不对是最典型的玄学bug。5.4 除法结果是5.0PL0是整除不是浮点除现象10 / 2输出5.0和常量5比较时类型不一致JPC判断时把5.0当成真值逻辑全乱。PL0里没有浮点数除法是整除。 原因Python的/是浮点除法//才是整除第2章虚拟机OPR指令编号5的实现里写成了/。 解决把第2章虚拟机里OPR的a5分支替换成下面这个除数为0要单独检查别让Python原生异常暴露在验收现场elif a 5: if self.s[self.sp] 0: raise ZeroDivisionError(运行时错误: 除数为0) self.s[self.sp-1] // self.s[self.sp]其实PL0标准里连运行时错误都不要求但除零在验收演示时一旦触发老师对你的印象会打折扣。提前拦下来比让解释器崩掉体面得多。5.5 答辩演示当场找不到文件路径问题现象在教室电脑上跑python main.py test.pl0报FileNotFoundError。 原因main.py里用了相对路径test.pl0当前工作目录不是源码目录时Python在当前工作目录找文件找不到就崩。 解决入口函数里把样例文件夹固定在源码目录下import os BASE os.path.dirname(os.path.abspath(__file__)) def load_case(name): path os.path.join(BASE, cases, name) with open(path, r, encodingutf-8-sig) as f: return f.read()这样不管你在哪个目录下运行都能通过__file__定位到源码目录个样例文件放在cases文件夹里路径永远稳定。演示前在讲台上完整跑一遍命令别用IDE的运行上次配置那个会带上IDE自己的工作目录换机器就露馅。6. 让课设从能跑变成能讲P-CODE dump与三个验收样例验收前的最后一个晚上别写新功能做两件验证工作把生成的P-CODE打印成带行号的清单准备三个能覆盖全部语法点的样例。P-CODE dump函数是答辩时最容易打动老师的输出一张指令清单直接证明你的编译器真的生成了目标代码def dump(code): names { 0: 返回, 1: 取负, 2: 加, 3: 减, 4: 乘, 5: 整除, 6: 奇偶, 8: , 9: #, 10: , 11: , 12: , 13: , } for i, ins in enumerate(code): if ins.op OPR: print(f{i:4d} {ins.op:4s} {names.get(ins.arg, ins.arg)}) else: print(f{i:4d} {ins.op:4s} {ins.lev} {ins.arg})三个样例我建议这样配。第一个覆盖const、var、运算和读写跑通最小路径const k3; var x,y; begin read(x); y : x k * 2; write(y) end.第二个覆盖while和嵌套begin/end验证回填逻辑var i,s; begin i:1; s:0; while i 100 do begin s : s i; i : i 1 end; write(s) end.第三个覆盖过程嵌套和递归算阶乘最经典过程里调用自己把静态链、动态链、活动记录全用上var n, f; procedure fact; begin if n 1 then f : 1 else begin n : n - 1; call fact; n : n 1; f : f * n end end; begin read(n); call fact; write(f) end.第三个样例跑通时你值得停下来看一眼虚拟机栈的变化——每一层递归调用CAL指令压入一帧新的活动记录返回时按动态链弹栈这个过程亲眼看过一遍比对任何教材描述都深刻。演示时准备这三样终端里编译运行的命令、P-CODE dump文件截图、第三个样例的递归栈讲解。老师问递归下降在哪里翻到parser.py指expression、term、factor问活动记录怎么管理翻到vm.py指call的三槽布局问错误怎么定位指lexer和parser的报错行号。我自己的习惯是每次做这类编译器课设都在项目根目录留一个最小复现脚本一条命令生成P-CODE并打印栈轨迹换机器、换机房电脑、换Python版本先跑最小样例通了再跑全量。这个习惯帮我避开了好几次验收当场的黑匣子问题。希望帮到你。本文还有配套的精品资源点击获取