编译原理实验的最后一部分，献上实验代码、PL\0代码、中间代码的详细说明
断断续续每天晚上干几十分钟至几个小时，中间还因为加班咕了几天，至此终于算是完成了！
PL\0代码
program id;
const m:=7, n:=85;
var x,y,z,q,r;
procedure multiply;
var a,b;
begin
a:=x; b:=y; z:=0;
while b>0 do
begin
if odd b then z:=z+a;
a:=2*a; b:=b/2
end
end
begin
x:=m; y:=n;
call multiply
end编译原理实验代码
import sys
# 错误提示函数,提示信息为程序第几行发生了什么错误
def error(line_num, message):
print('程序第' + str(line_num) + '行发生了错误：' + message)
'''词法分析部分所需的关键字表 算术符和分隔符表以及生成的token'''
key_word = ['program', 'const', 'var', 'procedure', 'begin', 'end', 'if', 'then', 'while', 'do', 'call', 'read',
'write'] # 程序的关键字
symbol = ['+', '-', '*', '/', '(', ')', '=', ',', ';'] # 算术符和分隔符
token_list = []
token_index = 0
# 按照空格分割成一个个单词,单词中会包括运算符、语法符号等,需要进一步划分
def deal_word(word, line_num):
length = len(word)
index = 0
while index < length:
token = dict()
value = '' # token的值
attribute = '' # token的属性
if word[index].isalpha(): # 字母开头 标识符或关键字
while index < length and (word[index].isalpha() or word[index].isdigit()):
value += word[index]
index += 1
if value in key_word: # 判断是否是关键字
attribute = 'keyword'
else:
attribute = 'identifier'
elif word[index].isdigit(): # 数字开头 数字
while index < length and word[index].isdigit():
value += word[index]
index += 1
value = int(value)
attribute = 'number'
elif word[index] == ':': # :开头 赋值符号:=
value += word[index]
index += 1
if index < length and word[index] == '=':
value += word[index]
index += 1
attribute = value
elif word[index] == '<': # <开头 可能是 < <= <>
value += word[index]
index += 1
if index < length and (word[index] == '=' or word[index] == '>'):
value += word[index]
index += 1
attribute = value
elif word[index] == '>': # >开头 > >=
value += word[index]
index += 1
if index < length and word[index] == '=':
value += word[index]
index += 1
attribute = value
elif word[index] in symbol: # 如果是语法符号
value = word[index]
attribute = word[index]
index += 1
else:
print('行数' + str(line_num) + ':非法字符' + word[index])
sys.exit(0)
# 填充到token表
token['value'] = value
token['line_num'] = line_num
token['attribute'] = attribute
token_list.append(token)
# 每次调用返回一个token
def get_token():
global token_index
if token_index >= len(token_list):
sys.exit(0)
token = token_list[token_index]
token_index += 1
return token
'''语法分析生成的符号表'''
table_list = [] # 符号表
mid_code = [] # 中间代码集合
level = 0 # 记录层数，每次遇到函数定义就加1
address = 0 # 每次符号表中登记变量和过程需要设置,作用是结合level知道每个变量和过程在数据栈中的位置或者函数跳转的位置
dx = 3 # 用来记录每一层次的开辟空间个数 默认是3 SL DL RA
# 记录符号表,
def record_table(name, kind, value=None, level=None, address=None, size=None):
table = dict()
table['name'] = name
table['kind'] = kind
table['value'] = value
table['level'] = level
table['address'] = address
table['size'] = size
table_list.append(table)
# 生成中间代码
def emit(f, l, a):
operation = dict()
operation['F'] = f
operation['L'] = l
operation['A'] = a
mid_code.append(operation)
# 查询符号表 返回在符号表中的下标
def find_table(val):
index = 0
for var in table_list:
if var['name'] == val:
return index
index += 1
return -1
# <prog> → program <id>；<block>
def prog():
token = get_token()
if token['value'] == 'program': # 第一个单词是program
token = get_token()
if token['attribute'] == 'identifier': # 第二个是程序名称
token = get_token()
if token['value'] == ';': # 第三个是分号 然后进入block阶段
block()
else:
error(token['line_num'], '前面缺少;')
else:
error(token['line_num'], '语法错误,缺少程序名称')
else:
error(token['line_num'], '缺少program关键字')
# <block> → [<condecl>][<vardecl>][<proc>]<body>
# 考虑到因为;缺失导致获取的下一个单词不方便放回去，所以condecl vardecl proc在block层进行解析
def block():
global dx
global level
global mid_code
global token_index
dx = 3 # 主函数以及定义的函数会调用block 默认入栈三个参数 SL DL RA
# 进入block先写一条跳转语句 地址后面回填
# 原因是假如block里面先进行函数定义，那么后续的指令不会执行，需要跳转到body部分，而body部分指令
# 的地址需要计算完函数的指令才会计算出来，所以先在这里插入一条，同时用cx1标记一下jmp指令的位置后面回填
cx1 = len(mid_code) # cx1表示jmp指令需要回填在指令集中的位置
emit('JMP', 0, 0)
token = get_token()
if token['value'] == 'const': # 常量表达式 <condecl> → const <const>{,<const>};
const()
token = get_token()
while token['value'] == ',':
const()
token = get_token()
if token['value'] == ';':
token = get_token()
else:
error(token['line_num'], '缺少;')
if token['value'] == 'var': # 变量表达式 <vardecl> → var <id>{,<id>};
token = get_token()
if token['attribute'] == 'identifier': # 对于变量要插入到符号表中 同时dx要加一表示栈空间增长
record_table(token['value'], 'VARIABLE', level=level, address=dx)
dx += 1
token = get_token()
else:
error(token['line_num'], 'var后面需要跟标识符')
while token['value'] == ',':
token = get_token()
if token['attribute'] == 'identifier':
record_table(token['value'], 'VARIABLE', level=level, address=dx)
dx += 1
token = get_token()
continue
if token['value'] == ';':
token = get_token()
else:
error(token['line_num'], '缺少;')
# 这里用while循环表示函数定义可以嵌套
while token['value'] == 'procedure': # 函数定义 <proc> → procedure <id>（[<id>{,<id>}]）;<block>{;<proc>}
token = get_token()
if token['attribute'] == 'identifier':
record_table(token['value'], 'PROCEDURE', level=level, address=len(mid_code))
token = get_token()
else:
error(token['line_num'], '函数名必须是标识符')
if token['value'] != ';': # 这里先不考虑函数带参数的情况 无非就是多写几个变量
error(token['line_num'], '缺少;')
token_index -= 1
# 下面进入block定义 进入block之前需要更新嵌套层数level 同时记录当前栈的情况便于恢复
level += 1 # 层级+1
cur_dx = dx # 记录当前层的变量个数
block()
level -= 1 # 结束后要恢复
dx = cur_dx # 恢复当前栈的变量数量
token = get_token()
if token['value'] == ';': # 如果是分号 继续进行proc
token = get_token()
else:
break
token_index -= 1 # 由于不再函数嵌套 需要回退一个单词
# 进入body之前先回填block开头的jmp指令
ins = dict()
ins['F'] = 'JMP'
ins['L'] = 0
ins['A'] = len(mid_code) # 跳转的地址就是body里指令的开头
mid_code[cx1] = ins
emit('INT', 0, dx) # 进入当前函数的body部分需要给定义的变量和SL DL RA开辟栈空间
body() # 进入body
emit('OPR', 0, 0) # 过程调用结束后,返回调用点并退栈
# <const> → <id>:=<integer>
def const():
token = get_token()
variable = token['value']
if token['attribute'] == 'identifier': # 这里有变量 需要记录在符号表中
token = get_token()
if token['value'] == ':=':
token = get_token()
if token['attribute'] == 'number':
record_table(variable, 'CONSTANT', value=token['value'], level=level)
else:
error(token['line_num'], ':=后面需要跟整数')
else:
error(token['line_num'], '缺少:=')
else:
error(token['line_num'], '缺少标识符')
# <body> → begin <statement>{;<statement>}end
def body():
global token_index
token = get_token()
if token['value'] != 'begin':
error(token['line_num'], '缺少begin')
token_index -= 1
statement()
token = get_token()
while token['value'] == ';': # 循环statement
statement()
token = get_token()
if token['value'] != 'end':
error(token['line_num'], '缺少end')
token_index -= 1
# <statement> → <id> := <exp>
# |if <lexp> then <statement>[else <statement>]
# |while <lexp> do <statement>
# |call <id>（[<exp>{,<exp>}]）
# |<body>
# |read (<id>{，<id>})
# |write (<exp>{,<exp>})
def statement():
global token_index
global level
token = get_token()
if token['value'] == 'end': # 这一步是因为如果最后有人多写了一个; 会继续进入statement,但实际上会退出
error(token['line_num'], ';是多余的')
token_index -= 1
return
if token['attribute'] == 'identifier': # <id> := <exp>
index = find_table(token['value'])
if index == -1:
error(token['line_num'], token['value'] + '未定义')
elif table_list[index]['kind'] != 'VARIABLE':
error(token['line_num'], table_list[index]['name'] + '不是一个变量')
token = get_token()
if token['value'] != ':=':
error(token['line_num'], '缺少:=')
token_index -= 1 # 需要回退一个
expression()
if index != -1: # 合法变量产生一个sto指令 从数据栈中取数据赋值给变量 关于为什么使用层差和地址会在解析指令地方解释
emit('STO', level - table_list[index]['level'], table_list[index]['address'])
elif token['value'] == 'if': # if <lexp> then <statement>[else <statement>]
lexp()
token = get_token()
if token['value'] != 'then':
error(token['line_num'], '缺少关键字then')
token_index -= 1
cx2 = len(mid_code) # cx2表示jpc指令需要回填在指令集中的位置
emit('JPC', 0, 0) # if语句先做jpc跳转到else的地方 后面回填
statement()
# 这里回填if语句不满足执行else的地址
ins = dict()
ins['F'] = 'JPC'
ins['L'] = 0
ins['A'] = len(mid_code) # 跳转的地址就是if语句不满足的地方
mid_code[cx2] = ins
token = get_token()
if token['value'] == 'else': # 判断是否还有
cx1 = len(mid_code)
emit('JMP', 0, 0)
statement()
# 这里回填if语句结束的地址
ins = dict()
ins['F'] = 'JMP'
ins['L'] = 0
ins['A'] = len(mid_code) # 跳转的地址就是if语句不满足的地方
mid_code[cx1] = ins
else:
token_index -= 1 # 没有则回退
# 这里回填if语句结束的地址
elif token['value'] == 'while': # while <lexp> do <statement>
jmp_addr = len(mid_code) # 这里保存while循环开始的语句 因为循环如果条件满足需要继续执行
lexp()
token = get_token()
# 地址指令回头填写
if token['value'] != 'do':
error(token['line_num'], '缺少do关键字')
token_index -= 1
cx2 = len(mid_code) # cx2表示jpc指令需要回填在指令集中的位置
emit('JPC', 0, 0) # if语句先做jpc跳转到else的地方 后面回填
statement()
# 插入一条jmp指令继续执行循环
emit('JMP', 0, jmp_addr)
# 回填jpc指令
ins = dict()
ins['F'] = 'JPC'
ins['L'] = 0
ins['A'] = len(mid_code) # 跳转的地址就是while语句结束的地方
mid_code[cx2] = ins
elif token['value'] == 'call': # call <id>（[<exp>{,<exp>}]）
token = get_token()
if token['attribute'] != 'identifier':
error(token['line_num'], '函数名必须是标识符')
else:
index = find_table(token['value'])
if index == -1:
error(token['line_num'], token['value'] + '未定义')
elif table_list[index]['kind'] == 'PROCEDURE':
emit('CAL', level - table_list[index]['level'], table_list[index]['address'])
else:
error(token['line_num'], token['value'] + '不是函数名')
else: # body
token_index -= 1
body()
# <exp> → [+|-]<term>{<aop><term>}
def expression():
global token_index
token = get_token()
if token['value'] == '+' or token['value'] == '-':
term()
if token['value'] == '-': # -号需要取反操作
emit('OPR', 0, 1)
else:
token_index -= 1 # 回退
term()
token = get_token()
while token['value'] == '+' or token['value'] == '-':
term()
if token['value'] == '+':
emit('OPR', 0, 2)
elif token['value'] == '-':
emit('OPR', 0, 3)
token = get_token()
token_index -= 1
# <term> → <factor>{<mop><factor>}
def term():
global token_index
factor()
token = get_token() # 处理乘除
while token['value'] == '*' or token['value'] == '/':
factor()
if token['value'] == '*':
emit('OPR', 0, 4)
elif token['value'] == '/':
emit('OPR', 0, 5)
token = get_token()
token_index -= 1 # 需要回退一个单词
# <id>|<integer>|(<exp>)
def factor():
global token_index
token = get_token()
if token['attribute'] == 'identifier': # 标识符要查符号表
index = find_table(token['value'])
if index == -1: # 未找到 报错
error(token['line_num'], token['value'] + '未定义')
else:
if table_list[index]['kind'] == 'CONSTANT': # 常量
emit('LIT', 0, table_list[index]['value']) # 把常量放入栈顶
elif table_list[index]['kind'] == 'VARIABLE':
emit('LOD', level - table_list[index]['level'], table_list[index]['address']) # 把
elif table_list[index]['kind'] == 'PROCEDURE':
error(token['line_num'], table_list[index]['name'] + '为过程名, 出错')
elif token['attribute'] == 'number': # 遇到数字
emit('LIT', 0, token['value'])
elif token['attribute'] == '(': # 遇到左括号要进入表达式
expression()
token = get_token()
if token['attribute'] != ')': # 没有右括号报错
error(token['line_num'], '缺少右括号')
token_index -= 1 # 要回退一个
# <lexp> → <exp> <lop> <exp>|odd <exp>
def lexp():
global token_index
token = get_token()
if token['value'] == 'odd':
expression()
emit('OPR', 0, 6) # 奇偶判断
else:
token_index -= 1 # 要先回退才能进入表达式
expression()
token = get_token()
if token['value'] != '=' and token['value'] != '<>' and token['value'] != '<' and token['value'] != '<=' \
and token['value'] != '>' and token['value'] != '>=':
error(token['line_num'], '缺少比较运算符')
token_index -= 1
expression()
if token['value'] == '=':
emit('OPR', 0, 8)
elif token['value'] == '<>':
emit('OPR', 0, 9)
elif token['value'] == '<':
emit('OPR', 0, 10)
elif token['value'] == '>=':
emit('OPR', 0, 11)
elif token['value'] == '>':
emit('OPR', 0, 12)
elif token['value'] == '<=':
emit('OPR', 0, 13)
# 这里开始进行中间代码解释执行
stack = [0 for i in range(0, 8000)] # 数据栈 前三个0是主函数的SL DL RA
# 根据当前B的值和level层差获取SL的值
def get_sl(B, level):
global stack
res_B = B
while level > 0:
res_B = stack[res_B]
level -= 1
return res_B
# 解释器
def interpreter():
# 先定义好需要用到的数据
global stack
B = 0 # 基址寄存器
T = 0 # 栈顶寄存器
I = None # 存放要执行的代码
P = 0 # 存放下一条要执行的代码在mid_code数组的下标
# 开始执行
I = mid_code[P]
P += 1
while P != 0: # P为0表示主函数结束 指令回到起点 那么就算执行结束
if I['F'] == 'JMP': # 直接跳转到对应指令
P = I['A']
elif I['F'] == 'JPC':
if stack[T] == 0: # 栈顶值为0才跳转
P = I['A']
T -= 1 # 无论是否跳转都要去除栈顶的值
elif I['F'] == 'INT':
T += I['A'] - 1 # 开辟空间
elif I['F'] == 'LOD':
T += 1
stack[T] = stack[get_sl(B, I['L']) + I['A']]
elif I['F'] == 'STO':
stack[get_sl(B, I['L']) + I['A']] = stack[T]
T -= 1
elif I['F'] == 'LIT':
T += 1
stack[T] = I['A']
elif I['F'] == 'CAL': # 函数调用
T += 1
stack[T] = get_sl(B, I['L'])
stack[T + 1] = B
stack[T + 2] = P
B = T
P = I['A']
elif I['F'] == 'OPR':
if I['A'] == 0: # 函数返回
T = B - 1
P = stack[T + 3]
B = stack[T + 2]
elif I['A'] == 1: # 取反操作
stack[T] = -stack[T]
elif I['A'] == 2: # 加法
T -= 1
stack[T] = stack[T] + stack[T + 1]
elif I['A'] == 3: # 减法
T -= 1
stack[T] = stack[T] - stack[T + 1]
elif I['A'] == 4: # 乘法
T -= 1
stack[T] = stack[T] * stack[T + 1]
elif I['A'] == 5: # 除法
T -= 1
stack[T] = int(stack[T] / stack[T + 1])
elif I['A'] == 6: # odd 奇偶
stack[T] = stack[T] % 2
elif I['A'] == 8: # ==
T -= 1
stack[T] = stack[T] == stack[T + 1]
elif I['A'] == 9: # !=
T -= 1
stack[T] = stack[T] != stack[T + 1]
elif I['A'] == 10: # <
T -= 1
stack[T] = stack[T] < stack[T + 1]
elif I['A'] == 11: # >=
T -= 1
stack[T] = stack[T] >= stack[T + 1]
elif I['A'] == 12: # >
T -= 1
stack[T] = stack[T] > stack[T + 1]
elif I['A'] == 13: # <=
T -= 1
stack[T] = stack[T] <= stack[T + 1]
I = mid_code[P] # 获取下一条指令
if P == 0:
break
P += 1 # 默认P+1获取下一条指令 除非跳转
if __name__ == '__main__':
# 第一步词法分析,读取代码文件分解成单词,每个单词会记录内容、属性、行号
with open('code.txt', 'r') as file:
line_num = 1
for line in file.readlines():
for word in line.strip().split():
deal_word(word, line_num)
line_num += 1
# 第二部进行语法分析,同时生成中间代码
prog() # 从prog作为入口去分析
# 第三部分把生成的中间代码解释执行
interpreter()
中间代码说明
上文的PL\0代码生成的中间代码
{'F': 'JMP', 'L': 0, 'A': 30} # 进入主函数
{'F': 'JMP', 'L': 0, 'A': 2} # 进入multiply函数
{'F': 'INT', 'L': 0, 'A': 5} # 开辟5个空间
{'F': 'LOD', 'L': 1, 'A': 3} # 将x值放入栈顶
{'F': 'STO', 'L': 0, 'A': 3} # 将栈顶值放入变量a
{'F': 'LOD', 'L': 1, 'A': 4} # 将y值放入栈顶
{'F': 'STO', 'L': 0, 'A': 4} # 将栈顶值放入变量b
{'F': 'LIT', 'L': 0, 'A': 0} # 将常数0放入栈顶
{'F': 'STO', 'L': 1, 'A': 5} # 将栈顶值放入变量z
{'F': 'LOD', 'L': 0, 'A': 4} # while循环开始 将变量b的值放入栈顶
{'F': 'LIT', 'L': 0, 'A': 0} # 将常数0放入栈顶
{'F': 'OPR', 'L': 0, 'A': 12} # 进行b > 0比较
{'F': 'JPC', 'L': 0, 'A': 29} # 不满足条件结束循环
{'F': 'LOD', 'L': 0, 'A': 4} # 将b值放入栈顶
{'F': 'OPR', 'L': 0, 'A': 6} # 判断栈顶值是否是偶数
{'F': 'JPC', 'L': 0, 'A': 20} # if语句不满足条件跳转
{'F': 'LOD', 'L': 1, 'A': 5} # 取z的值放入栈顶
{'F': 'LOD', 'L': 0, 'A': 3} # 取a的值放入栈顶
{'F': 'OPR', 'L': 0, 'A': 2} # 次栈顶与栈顶相加
{'F': 'STO', 'L': 1, 'A': 5} # 将栈顶值放入变量z
{'F': 'LIT', 'L': 0, 'A': 2} # 取常数2放入栈顶
{'F': 'LOD', 'L': 0, 'A': 3} # 取变量a放入栈顶
{'F': 'OPR', 'L': 0, 'A': 4} # 次栈顶与栈顶相乘
{'F': 'STO', 'L': 0, 'A': 3} # 栈顶数赋值给变量a
{'F': 'LOD', 'L': 0, 'A': 4} # 取变量b放入栈顶
{'F': 'LIT', 'L': 0, 'A': 2} # 取常数2放入栈顶
{'F': 'OPR', 'L': 0, 'A': 5} # 次栈顶与栈顶相除
{'F': 'STO', 'L': 0, 'A': 4} # 栈顶数赋值给变量b
{'F': 'JMP', 'L': 0, 'A': 9} # 回到while循环
{'F': 'OPR', 'L': 0, 'A': 0} # 结束multiply函数
{'F': 'INT', 'L': 0, 'A': 8} # 主函数开始的地方
{'F': 'LIT', 'L': 0, 'A': 7} # 常数7放入栈顶
{'F': 'STO', 'L': 0, 'A': 3} # 栈顶数赋给变量x
{'F': 'LIT', 'L': 0, 'A': 85} # 常数85放入栈顶
{'F': 'STO', 'L': 0, 'A': 4} # 栈顶数赋值给变量y
{'F': 'CAL', 'L': 0, 'A': 1} # 跳转执行函数
{'F': 'OPR', 'L': 0, 'A': 0} # 结束主函数