构建Python解释器基础
在构建一个语言解释器时，通常会涉及两个核心阶段：词法分析（lexing）和语法分析（parsing）。
词法分析器（Lexer）: 负责将源代码字符串分解成一系列有意义的“令牌”（tokens）。例如，将print "HELLO"分解为PRINT令牌和STRING:"HELLO"令牌。在提供的代码中，lex函数承担了这一职责，它将输入文件内容转换为如["PRINT", "STRING:\"HELLO WORLD\"", "PRINT", "STRING:\"string\"", "NUM:566755664645454", "EXPR:5+6", "PRINT", "NUM:55", "PRINT", "EXPR:5+8"]这样的令牌列表。
语法分析器（Parser）: 负责接收词法分析器生成的令牌流，并根据语言的语法规则构建抽象语法树（AST）或直接执行相应的操作。在提供的代码中，parse函数的目标是识别如PRINT STRING、PRINT NUM、PRINT EXPR等模式，并执行打印操作。
例如，对于以下语言输入：
PRINT "HELLO WORLD" print "string" 566755664645454 5 + 6 print 55 print 5 + 8
lex函数会将其转换为一个令牌列表，parse函数则需要遍历这个列表并执行对应的操作。
立即学习“Python免费学习笔记（深入）”；
问题诊断：解析器中的无限循环
在解释器开发中，一个常见的错误是解析器进入无限循环。原始代码在执行时，仅打印了前两个字符串，随后便抛出了KeyboardInterrupt错误，这通常是由于程序陷入了死循环，用户不得不手动中断执行。
PS C:\Users\essam\Desktop\spl> python basic.py test.lang "HELLO WORLD" "string" Traceback (most recent call last): File "C:\Users\essam\Desktop\spl\basic.py", line 73, inrun() File "C:\Users\essam\Desktop\spl\basic.py", line 71, in run parse(toks) File "C:\Users\essam\Desktop\spl\basic.py", line 58, in parse while(i < len(toks)): ^^^^^^^^^ KeyboardInterrupt
错误堆栈指向了parse函数内部的while循环条件while(i
分析原始的parse函数：
def parse(toks):
i = 0
while(i < len(toks)):
# 只有当满足 "PRINT STRING" 或 "PRINT NUM" 或 "PRINT EXPR" 条件时，i才递增
if toks[i] + " " + toks[i+1][0:6] == "PRINT STRING" or \
toks[i] + " " + toks[i+1][0:3] == "PRINT NUM" or \
toks[i] + " " + toks[i+1][0:4] == "PRINT EXPR":
if toks[i+1][0:6] == "STRING":
print(toks[i+1][7:])
elif toks[i+1][0:3] == "NUM":
print(toks[i+1][4:])
elif toks[i+1][0:4] == "EXPR":
print(toks[i+1][5:])
i+= 2 # 递增操作被嵌套在if条件内部问题在于，i += 2这行代码被严格地放置在if条件块内部。这意味着，只有当toks[i]和toks[i+1]的组合精确匹配PRINT STRING、PRINT NUM或PRINT EXPR这三种模式之一时，i才会递增。
考虑以下场景：
- 解析器处理完PRINT "HELLO WORLD"和print "string"后，i的值为4。
- 下一个令牌是NUM:566755664645454 (toks[4])。
- 此时，if条件toks[4] + " " + toks[5][0:6] == "PRINT STRING"等将不再满足（因为toks[4]不是PRINT）。
- 由于if条件不满足，i += 2这行代码不会被执行。
- i的值保持为4，while循环的条件i
核心修复：确保循环变量递增
解决无限循环问题的核心在于确保在while循环的每一次迭代中，无论是否匹配到特定的语法模式，循环变量i都必须有所进展。最直接的修复是将i的递增操作移到if条件块之外，使其在每次循环结束时都能够执行。
def parse(toks):
i = 0
while i < len(toks):
# 确保有足够的令牌进行检查，避免 IndexError
if i + 1 < len(toks) and \
toks[i] == "PRINT" and \
(toks[i+1].startswith("STRING:") or \
toks[i+1].startswith("NUM:") or \
toks[i+1].startswith("EX:")): # 注意：EXPR的简写是EX
# 处理 PRINT 语句
if toks[i+1].startswith("STRING:"):
print(toks[i+1][7:])
elif toks[i+1].startswith("NUM:"):
print(toks[i+1][4:])
elif toks[i+1].startswith("EXPR:"): # 修正为 EXPR
print(toks[i+1][5:])
i += 2 # 处理了 PRINT 和其参数，i递增2
else:
# 如果不匹配 PRINT 语句模式，也必须递增 i，避免无限循环
# 这里简单地跳过当前令牌，实际应用中可能需要更复杂的错误处理
print(f"Warning: Unhandled token or syntax error at index {i}: {toks[i]}")
i += 1 # 只处理了当前令牌，i递增1通过将i的递增操作（i += 1或i += 2）放置在if/else结构的所有分支中，或者在if块外部（如果所有情况都递增相同步长），可以保证i在每次循环中都会前进，最终使i达到len(toks)，从而终止循环。
增强解析器：处理多种令牌类型
原始parse函数仅关注以PRINT开头的语句。然而，根据提供的测试用例，还有像566755664645454（NUM类型）和5 + 6（EXPR类型）这样的独立令牌，它们也需要被处理。为了使解析器更健壮和完整，我们需要扩展其逻辑来处理这些非PRINT开头的令牌。
以下是一个更完善的parse函数，它不仅解决了无限循环问题，还能够识别和处理独立的NUM和EXPR令牌，并加入了必要的边界条件检查：
def parse(toks):
i = 0
while i < len(toks):
current_token = toks[i]
# 1. 处理 PRINT 语句
if current_token == "PRINT":
# 确保 PRINT 后面有参数令牌
if i + 1 < len(toks):
next_token = toks[i+1]
if next_token.startswith("STRING:"):
print(next_token[7:]) # 打印字符串内容
i += 2 # 消耗了 PRINT 和 STRING 两个令牌
elif next_token.startswith("NUM:"):
print(next_token[4:]) # 打印数字内容
i += 2 # 消耗了 PRINT 和 NUM 两个令牌
elif next_token.startswith("EXPR:"):
print(next_token[5:]) # 打印表达式内容
i += 2 # 消耗了 PRINT 和 EXPR 两个令牌
else:
# PRINT 后面跟着无法识别的令牌
print(f"Error: Unexpected token after PRINT: {next_token}")
i += 2 # 即使是错误，也要前进，避免死循环
else:
# PRINT 语句缺少参数
print("Error: PRINT statement missing argument.")
i += 1 # 消耗 PRINT 令牌，继续
# 2. 处理独立的 NUM 令牌
elif current_token.startswith("NUM:"):
print(current_token[4:]) # 打印数字内容
i += 1 # 消耗 NUM 令牌
# 3. 处理独立的 EXPR 令牌
elif current_token.startswith("EXPR:"):
print(current_token[5:]) # 打印表达式内容
i += 1 # 消耗 EXPR 令牌
# 4. 处理独立的 STRING 令牌 (如果需要)
elif current_token.startswith("STRING:"):
print(current_token[7:]) # 打印字符串内容
i += 1 # 消耗 STRING 令牌
# 5. 遇到其他未处理的令牌类型
else:
print(f"Warning: Unhandled token type: {current_token}. Skipping.")
i += 1 # 消耗当前令牌，继续代码解释：
- 边界条件检查: if i + 1
-
多分支处理: 使用elif结构，根据current_token的类型进行不同的处理。
- 如果遇到PRINT，则进一步检查
