768 lines
30 KiB
Python
768 lines
30 KiB
Python
"""
|
||
语法分析
|
||
"""
|
||
from syntax.rule import Sign, Production, terminal_sign_type, non_terminal_sign_type, productions, grammar_start
|
||
from error import SyntaxRuleError, SyntaxError, SemanticRuleError
|
||
from semantic.rule import SemanticRule, SemanticError, SemanticRuleFactory
|
||
|
||
|
||
class PredictingAnalysisTable:
|
||
"""
|
||
预测分析表
|
||
"""
|
||
def __init__(self):
|
||
"""
|
||
构造
|
||
"""
|
||
# 错误
|
||
self.__error = None
|
||
|
||
# 预测分析表
|
||
self.__table = list()
|
||
|
||
# 所有的非终结符
|
||
self.__non_terminal_signs = list()
|
||
# 所有的终结符
|
||
self.__terminal_signs = list()
|
||
|
||
# 载入所有的符号
|
||
for i in non_terminal_sign_type:
|
||
self.__non_terminal_signs.append(Sign(i))
|
||
for i in terminal_sign_type:
|
||
self.__terminal_signs.append(Sign(i))
|
||
|
||
# 根据非终结符和终结符的数量为预测分析表分配空间，并且为每一个格子预先填上 None
|
||
for i in non_terminal_sign_type:
|
||
self.__table.append(list())
|
||
for i in range(0, len(non_terminal_sign_type)):
|
||
for j in terminal_sign_type:
|
||
self.__table[i].append(None)
|
||
|
||
# 为每一个非终结符建立 first 集和 follow 集
|
||
self.__firsts = list()
|
||
self.__follows = list()
|
||
|
||
# 为每一个非终结符的 first 集和 follow 集分配空间
|
||
for i in non_terminal_sign_type:
|
||
self.__firsts.append(list())
|
||
self.__follows.append(list())
|
||
|
||
def compile(self):
|
||
"""
|
||
编译预测分析表
|
||
"""
|
||
# 对每一个文法元素求其 first 集
|
||
self.__calculate_firsts()
|
||
# 对每一个文法元素求其 follow 集
|
||
self.__calculate_follows()
|
||
# 根据 first 集和 follow 集生成预测分析表
|
||
success = self.__generate_table()
|
||
return success
|
||
|
||
|
||
def get_production(self, non_terminal_sign, terminal_sign):
|
||
"""
|
||
从预测分析表中获取产生式
|
||
:param non_terminal_sign: 非终结符
|
||
:param terminal_sign: 终结符
|
||
:return: 产生式
|
||
"""
|
||
x = self.__get_non_terminal_sign_index(non_terminal_sign)
|
||
y = self.__get_terminal_sign_index(terminal_sign)
|
||
return self.__table[x][y]
|
||
|
||
@classmethod
|
||
def __set_add(cls, container, sign):
|
||
"""
|
||
将 sign 添加到 container 中并返回 True，如果其中已经有该元素了则返回 False
|
||
:param container: 要添加到的集合
|
||
:param sign: 符号
|
||
:return: 添加是否成功
|
||
"""
|
||
exist = False
|
||
for elem in container:
|
||
if elem.type == sign.type:
|
||
exist = True
|
||
if not exist:
|
||
container.append(sign)
|
||
return not exist
|
||
|
||
def __get_terminal_sign_index(self, terminal_sign):
|
||
"""
|
||
获取终结符的索引
|
||
:param terminal_sign: 终结符
|
||
:return: 索引(寻找失败返回 -1)
|
||
"""
|
||
for i in range(0, len(self.__terminal_signs)):
|
||
if terminal_sign.type == self.__terminal_signs[i].type:
|
||
return i
|
||
return -1
|
||
|
||
def __get_non_terminal_sign_index(self, non_terminal_sign):
|
||
"""
|
||
获取非终结符的索引
|
||
:param non_terminal_sign: 非终结符
|
||
:return: 索引(寻找失败返回 -1)
|
||
"""
|
||
for i in range(0, len(self.__non_terminal_signs)):
|
||
if non_terminal_sign.type == self.__non_terminal_signs[i].type:
|
||
return i
|
||
return -1
|
||
|
||
def __get_non_terminal_sign_first(self, non_terminal_sign):
|
||
"""
|
||
获取目标非终结符的 first 集的引用
|
||
:param non_terminal_sign: 目标非终结符
|
||
:return: 其 first 集的引用
|
||
"""
|
||
return self.__firsts[self.__get_non_terminal_sign_index(non_terminal_sign)]
|
||
|
||
def __get_non_terminal_sign_first_no_empty(self, non_terminal_sign):
|
||
"""
|
||
获取目标非终结符的 first 集的非空拷贝
|
||
:param non_terminal_sign: 目标非终结符
|
||
:return: 其 first 集的非空拷贝
|
||
"""
|
||
result = list()
|
||
for i in self.__get_non_terminal_sign_first(non_terminal_sign):
|
||
if not i.is_empty_sign():
|
||
result.append(i)
|
||
return result
|
||
|
||
def __is_empty_in_non_terminal_sign_first(self, non_terminal_sign):
|
||
"""
|
||
目标非终结符的 first 集中是否有空字
|
||
:param non_terminal_sign: 目标非终结符
|
||
:return: True/False
|
||
"""
|
||
for i in self.__get_non_terminal_sign_first(non_terminal_sign):
|
||
if i.is_empty_sign():
|
||
return True
|
||
return False
|
||
|
||
def __get_non_terminal_sign_follow(self, non_terminal_sign):
|
||
"""
|
||
获取非终结符的 follow 集
|
||
:param non_terminal_sign: 非终结符
|
||
:return: 其 follow 集
|
||
"""
|
||
return self.__follows[self.__get_non_terminal_sign_index(non_terminal_sign)]
|
||
|
||
def __calculate_firsts(self):
|
||
"""
|
||
求所有的 first 集
|
||
"""
|
||
# 立一个 flag，用来标志 firsts 集是否增大
|
||
flag = True
|
||
# 开始循环
|
||
while flag:
|
||
flag = False
|
||
# 在每一次循环之中遍历所有产生式
|
||
for production in productions:
|
||
# 如果产生式右边为空
|
||
if len(production.right) == 0:
|
||
# 将空字加入其 first 集
|
||
if self.__set_add(self.__get_non_terminal_sign_first(production.left), Sign('empty')):
|
||
flag = True
|
||
# 如果产生式右边不为空
|
||
else:
|
||
# 如果是以终结符开头，将终结符添加到其 first 集
|
||
if production.right[0].is_terminal_sign():
|
||
if self.__set_add(self.__get_non_terminal_sign_first(production.left), production.right[0]):
|
||
flag = True
|
||
# 如果是以非终结符开头
|
||
elif production.right[0].is_non_terminal_sign():
|
||
# (1) 将开头非终结符的 first 集中的所有非空元素添加到产生式左边非终结符的 first 集中
|
||
bigger = False
|
||
for i in self.__get_non_terminal_sign_first_no_empty(production.right[0]):
|
||
if self.__set_add(self.__get_non_terminal_sign_first(production.left), i):
|
||
bigger = True
|
||
if bigger:
|
||
flag = True
|
||
|
||
# (2) 从第一个非终结符开始循环，如果其 first 集中包含空字，那么将它下一个符号的 first
|
||
# 集添加到产生式左边非终结符的 first 集中去
|
||
for i in range(0, len(production.right)):
|
||
if production.right[i].is_non_terminal_sign():
|
||
# 如果包含空字
|
||
if self.__is_empty_in_non_terminal_sign_first(production.right[i]):
|
||
# 如果它是最后一个，将空字填入
|
||
if i == len(production.right) - 1:
|
||
if self.__set_add(self.__get_non_terminal_sign_first(production.left),
|
||
Sign('empty')):
|
||
flag = True
|
||
# 如果不是最后一个
|
||
else:
|
||
# 如果它之后是终结符
|
||
if production.right[i + 1].is_terminal_sign():
|
||
if self.__set_add(self.__get_non_terminal_sign_first(production.left),
|
||
production.right[i + 1]):
|
||
flag = True
|
||
# 如果它之后是非终结符
|
||
elif production.right[i + 1].is_non_terminal_sign():
|
||
bigger = False
|
||
for j in self.__get_non_terminal_sign_first_no_empty(
|
||
production.right[i + 1]):
|
||
if self.__set_add(
|
||
self.__get_non_terminal_sign_first(production.left), j):
|
||
bigger = True
|
||
if bigger:
|
||
flag = True
|
||
else:
|
||
self.__error = SyntaxRuleError('终结符或非终结符类型错误')
|
||
return False
|
||
# 如果不包含空字
|
||
else:
|
||
break
|
||
else:
|
||
break
|
||
# 否则报错
|
||
else:
|
||
self.__error = SyntaxRuleError('终结符或非终结符类型错误')
|
||
return False
|
||
|
||
def __calculate_follows(self):
|
||
"""
|
||
求所有的 follow 集
|
||
"""
|
||
first = list()
|
||
flag = True
|
||
while flag:
|
||
flag = False
|
||
# 遍历所有产生式
|
||
for production in productions:
|
||
# 如果产生式左边是开始符号
|
||
if production.left.type == grammar_start.type:
|
||
if self.__set_add(self.__get_non_terminal_sign_follow(production.left), Sign('pound')):
|
||
flag = True
|
||
|
||
# 遍历产生式右边
|
||
for i in range(0, len(production.right)):
|
||
# 如果是非终结符
|
||
if production.right[i].is_non_terminal_sign():
|
||
# 如果它是产生式最后一个符号
|
||
if i == len(production.right) - 1:
|
||
# 将产生式左边非终结符的 follow 集添加到这个符号的 follow 集中
|
||
bigger = False
|
||
for j in self.__get_non_terminal_sign_follow(production.left):
|
||
if self.__set_add(self.__get_non_terminal_sign_follow(production.right[i]), j):
|
||
bigger = True
|
||
if bigger:
|
||
flag = True
|
||
# 否则观察其之后的元素
|
||
else:
|
||
# 求他之后所有符号集合的 first 集
|
||
first.clear()
|
||
first += self.__calculate_set_first(production.right[i + 1:])
|
||
# (1) 将 first 中所有非空元素填入 follow
|
||
empty_find = False
|
||
for f in first:
|
||
if not f.is_empty_sign():
|
||
self.__set_add(self.__get_non_terminal_sign_follow(production.right[i]), f)
|
||
else:
|
||
empty_find = True
|
||
|
||
# (2) 如果 first 中含有空
|
||
if empty_find:
|
||
# 将产生式左边非终结符的 follow 集添加到这个符号的 follow 集中
|
||
bigger = False
|
||
for j in self.__get_non_terminal_sign_follow(production.left):
|
||
if self.__set_add(self.__get_non_terminal_sign_follow(production.right[i]), j):
|
||
bigger = True
|
||
if bigger:
|
||
flag = True
|
||
|
||
# # 如果他后面是一个终结符
|
||
# if production.right[i + 1].is_terminal_sign():
|
||
# if self.__set_add(self.__get_non_terminal_sign_follow(production.right[i]),
|
||
# production.right[i + 1]):
|
||
# flag = True
|
||
# # 如果他后面是一个非终结符
|
||
# elif production.right[i + 1].is_non_terminal_sign():
|
||
# # (1) 将后面非终结符的 first 集中的所有非空元素填入
|
||
# bigger = False
|
||
# for j in self.__get_non_terminal_sign_first_no_empty(production.right[i + 1]):
|
||
# if self.__set_add(self.__get_non_terminal_sign_follow(production.right[i]), j):
|
||
# bigger = True
|
||
# if bigger:
|
||
# flag = True
|
||
#
|
||
# # (2) 如果后面所有的非终结符 first 集都包含空
|
||
# # 那么，则将产生式左边的 follow 集添加到该非终结符的 follow 集中去
|
||
# all_empty_in_first = True
|
||
# for j in range(i + 1, len(production.right)):
|
||
# if not self.__is_empty_in_non_terminal_sign_first(production.right[j]):
|
||
# all_empty_in_first = False
|
||
# break
|
||
# if all_empty_in_first:
|
||
# bigger = False
|
||
# for j in self.__get_non_terminal_sign_follow(production.left):
|
||
# if self.__set_add(self.__get_non_terminal_sign_follow(production.right[i]), j):
|
||
# bigger = True
|
||
# if bigger:
|
||
# flag = True
|
||
# # 否则报错
|
||
# else:
|
||
# self.__error = SyntaxRuleError('终结符或非终结符类型错误')
|
||
# return False
|
||
# 如果是终结符
|
||
elif production.right[i].is_terminal_sign():
|
||
continue
|
||
# 否则报错
|
||
else:
|
||
self.__error = SyntaxRuleError('终结符或非终结符类型错误')
|
||
return False
|
||
|
||
def __calculate_set_first(self, container):
|
||
"""
|
||
计算一系列符号的 first 集
|
||
:param container: 符号集合
|
||
:return: first 集
|
||
"""
|
||
first = list()
|
||
|
||
# 开始求 first 集
|
||
# 如果集合为空
|
||
first = list()
|
||
|
||
# 开始求 first 集
|
||
# 如果产生式右边为空
|
||
if len(container) == 0:
|
||
# 将空字加入其 first 集
|
||
self.__set_add(first, Sign('empty'))
|
||
# 如果产生式右边补位空
|
||
else:
|
||
# 如果是以终结符开头，将终结符添加到 first 集
|
||
if container[0].is_terminal_sign():
|
||
self.__set_add(first, container[0])
|
||
# 如果是以非终结符开头
|
||
elif container[0].is_non_terminal_sign():
|
||
# (1) 将开头非终结符的 first 集中的所有非空元素添加到 first 中
|
||
for i in self.__get_non_terminal_sign_first_no_empty(container[0]):
|
||
self.__set_add(first, i)
|
||
|
||
# (2) 从第一个非终结符开始循环，如果其 first 集中包含空字，那么将它的下一个符号的 first
|
||
# 集添加到 first 中
|
||
for i in range(0, len(container)):
|
||
if container[i].is_non_terminal_sign():
|
||
# 如果包含空字
|
||
if self.__is_empty_in_non_terminal_sign_first(container[i]):
|
||
# 如果它是最后一个，将空字填入
|
||
if i == len(container) - 1:
|
||
self.__set_add(first, Sign('empty'))
|
||
# 如果不是最后一个
|
||
else:
|
||
# 如果它之后是终结符
|
||
if container[i + 1].is_terminal_sign():
|
||
self.__set_add(first, container[i + 1])
|
||
# 如果它之后是非终结符
|
||
elif container[i + 1].is_non_terminal_sign():
|
||
for j in self.__get_non_terminal_sign_first_no_empty(container[i + 1]):
|
||
self.__set_add(first, j)
|
||
# 否则报错
|
||
else:
|
||
self.__error = SyntaxRuleError('终结符或非终结符类型错误')
|
||
return False
|
||
# 如果不含空字
|
||
else:
|
||
break
|
||
else:
|
||
break
|
||
# 否则报错
|
||
else:
|
||
self.__error = SyntaxRuleError('终结符或非终结符类型错误')
|
||
return False
|
||
|
||
return first
|
||
|
||
def __insert_to_table(self, production, terminal):
|
||
"""
|
||
将产生式插入预测分析表对应位置
|
||
:param production: 产生式
|
||
:param terminal: 终结符
|
||
:return: 是否插入成功
|
||
"""
|
||
# 先判断应该插入到的位置
|
||
x = self.__get_non_terminal_sign_index(production.left)
|
||
y = self.__get_terminal_sign_index(terminal)
|
||
|
||
# 如果那个位置已经有产生式了
|
||
if self.__table[x][y]:
|
||
# 判断这个产生式是不是与要插入的产生式一样
|
||
same_left = production.left.type == self.__table[x][y].left.type
|
||
if same_left:
|
||
same_right = True
|
||
if len(production.right) != len(self.__table[x][y].right):
|
||
self.__error = SyntaxRuleError("文法非LL(1)" + production.str)
|
||
return False
|
||
else:
|
||
for i in range(0, len(production.right)):
|
||
if production.right[i].type != self.__table[x][y].right[i].type:
|
||
same_right = False
|
||
if same_right:
|
||
# 执行插入
|
||
del self.__table[x][y]
|
||
self.__table[x].insert(y, production)
|
||
return True
|
||
else:
|
||
self.__error = SyntaxRuleError("文法非LL(1)" + production.str)
|
||
return False
|
||
else:
|
||
self.__error = SyntaxRuleError("文法非LL(1)" + production.str)
|
||
return False
|
||
# 如果那个位置为空，说明可以填入
|
||
else:
|
||
# 执行插入
|
||
del self.__table[x][y]
|
||
self.__table[x].insert(y, production)
|
||
return True
|
||
|
||
@classmethod
|
||
def __set_have_repeat(cls, set1, set2):
|
||
"""
|
||
判断两个集合是否有交集
|
||
:param set1: 集合1
|
||
:param set2: 集合2
|
||
:return: 是否有交集
|
||
"""
|
||
for i in set1:
|
||
for j in set2:
|
||
if i.type == j.type:
|
||
return True
|
||
return False
|
||
|
||
def __grammar_rule_debug(self):
|
||
"""
|
||
调试使用，求一个非终结符对应的所有产生式右边的 first 集中是否有相交元素
|
||
"""
|
||
# 一个非终结符对应的所有产生式
|
||
his_productions = list()
|
||
# 那些产生式对应的 first 集
|
||
firsts = list()
|
||
# 错误
|
||
errors = list()
|
||
|
||
# 对于所有的非终结符
|
||
for non_terminal_sign in self.__non_terminal_signs:
|
||
# 寻找他对应的所有产生式
|
||
his_productions.clear()
|
||
firsts.clear()
|
||
for production in productions:
|
||
if non_terminal_sign.type == production.left.type:
|
||
his_productions.append(production)
|
||
|
||
# 对于那些产生式，分别求 first 集
|
||
for production in his_productions:
|
||
firsts.append(self.__calculate_set_first(production.right))
|
||
|
||
|
||
|
||
# 是否有交集
|
||
have_repeat = False
|
||
# 查看这些产生式的 first 集两两之间是否有交集
|
||
for i in range(0, len(his_productions) - 1):
|
||
for j in range(i + 1, len(his_productions)):
|
||
|
||
if self.__set_have_repeat(firsts[i], firsts[j]):
|
||
have_repeat = True
|
||
break
|
||
|
||
|
||
# 如果有交集
|
||
if have_repeat:
|
||
errors.append('产生式 First 集重叠 ' + '非终结符: ' + non_terminal_sign.type)
|
||
|
||
# 如果非终结符的 First 集中包含空字
|
||
if self.__is_empty_in_non_terminal_sign_first(non_terminal_sign):
|
||
# 如果他的 First 集和 Follow 集有交集
|
||
if self.__set_have_repeat(self.__get_non_terminal_sign_first(non_terminal_sign),
|
||
self.__get_non_terminal_sign_follow(non_terminal_sign)):
|
||
errors.append('产生式 First 集和 Follow 集重叠 ' + '非终结符: ' + non_terminal_sign.type)
|
||
return
|
||
|
||
def __generate_table(self):
|
||
"""
|
||
根据 first 集和 follow 集生成预测分析表
|
||
:return: 是否生成成功
|
||
"""
|
||
# 调试
|
||
self.__grammar_rule_debug()
|
||
|
||
# 对每一条产生式应用规则
|
||
for production in productions:
|
||
# 先求出该产生式右边部分的 first 集
|
||
first = self.__calculate_set_first(production.right)
|
||
|
||
# 对每一个 first 集中的每一个终结符执行操作
|
||
empty_find = False
|
||
for i in list(first):
|
||
if i.type == 'empty':
|
||
empty_find = True
|
||
else:
|
||
if not self.__insert_to_table(production, i):
|
||
return False
|
||
|
||
# 如果其 first 集中有空字，则对 follow 集中的每一个终结符执行操作
|
||
if empty_find:
|
||
for i in self.__get_non_terminal_sign_follow(production.left):
|
||
if not self.__insert_to_table(production, i):
|
||
return False
|
||
|
||
return True
|
||
|
||
|
||
class Node:
|
||
"""
|
||
树节点
|
||
"""
|
||
def __init__(self, data):
|
||
"""
|
||
树节点
|
||
:param data: 节点数据
|
||
"""
|
||
self.data = data
|
||
self.str = data.type
|
||
self.children = list()
|
||
self.parent = None
|
||
|
||
# 属性
|
||
self.lexical = None
|
||
self.array = None
|
||
self.code = list()
|
||
self.type = None
|
||
self.id = None
|
||
self.length = None
|
||
self.fun = None
|
||
self.num = None
|
||
self.names = list()
|
||
self.bool = None
|
||
self.op = None
|
||
self.add = None
|
||
self.mul = None
|
||
|
||
def get_pre_brother(self, index):
|
||
"""
|
||
获取它前 index 位的兄弟
|
||
:param index: ..
|
||
:return: 兄弟
|
||
"""
|
||
self_index = 0
|
||
for i in range(0, len(self.parent.children)):
|
||
if self.parent.children[i] is self:
|
||
self_index = i
|
||
return self.parent.children[self_index - index]
|
||
|
||
|
||
class Tree:
|
||
"""
|
||
树
|
||
"""
|
||
def __init__(self, root):
|
||
"""
|
||
构造
|
||
:param root: 树的根节点
|
||
"""
|
||
self.root = root
|
||
|
||
|
||
class Stack:
|
||
"""
|
||
栈
|
||
"""
|
||
def __init__(self):
|
||
"""
|
||
构造
|
||
"""
|
||
self.__container = list()
|
||
|
||
def push(self, elem):
|
||
"""
|
||
入栈
|
||
:param elem: 入栈元素
|
||
"""
|
||
self.__container.append(elem)
|
||
|
||
def pop(self):
|
||
"""
|
||
将栈顶元素出栈
|
||
:return: 栈顶元素
|
||
"""
|
||
top = self.top()
|
||
self.__container.pop()
|
||
return top
|
||
|
||
def top(self):
|
||
"""
|
||
获取栈顶元素
|
||
:return: 栈顶元素
|
||
"""
|
||
return self.__container[-1]
|
||
|
||
def empty(self):
|
||
"""
|
||
栈是否为空
|
||
:return: 栈是否为空
|
||
"""
|
||
return len(self.__container) == 0
|
||
|
||
|
||
class Syntax:
|
||
"""
|
||
语法分析器
|
||
"""
|
||
def __init__(self):
|
||
"""
|
||
构造
|
||
"""
|
||
# 语法树的构建
|
||
self.__grammar_tree = None
|
||
# 准备存放错误
|
||
self.__error = list()
|
||
# 预测分析表的构建
|
||
self.__pa_table = PredictingAnalysisTable()
|
||
# 编译预测分析表
|
||
if self.__pa_table.compile():
|
||
self.__error.append(SyntaxRuleError('预测分析表编译失败'))
|
||
# 准备存放词法分析的结果
|
||
self.__source = list()
|
||
# 将词法分析产生的 token 转换成的终结符
|
||
self.__terminals = list()
|
||
|
||
def put_source(self, source):
|
||
"""
|
||
装填词法分析结果
|
||
:param source: 词法分析结果
|
||
"""
|
||
self.__source.clear()
|
||
self.__terminals.clear()
|
||
# 装填词法分析结果
|
||
for s in source:
|
||
self.__source.append(s)
|
||
# 将 tokens 转换成终结符
|
||
for s in self.__source:
|
||
self.__terminals.append(Sign(s.type, s.str, s.line))
|
||
# 在所有 tokens 的最后填入一个 #
|
||
self.__terminals.append(Sign('pound'))
|
||
|
||
def get_result(self):
|
||
"""
|
||
获取语法树
|
||
:return: 语法树
|
||
"""
|
||
return self.__grammar_tree
|
||
|
||
def get_error(self):
|
||
"""
|
||
获取错误
|
||
:return: 错误
|
||
"""
|
||
return self.__error
|
||
|
||
def execute(self):
|
||
"""
|
||
执行操作
|
||
:return: 语法分析是否成功
|
||
"""
|
||
# 新建栈
|
||
stack = Stack()
|
||
# 清空错误
|
||
self.__error = None
|
||
# 新建临时语法树
|
||
grammar_tree = Tree(Node(Sign(grammar_start.type)))
|
||
|
||
# 将 # 入栈
|
||
stack.push(Node(Sign('pound')))
|
||
# 将语法树根节点入栈
|
||
stack.push(grammar_tree.root)
|
||
|
||
# 拷贝转换之后的终结符到输入串
|
||
inputs = list()
|
||
for sign in self.__terminals:
|
||
inputs.append(sign)
|
||
# 设置当前输入符号索引
|
||
input_index = 0
|
||
|
||
# 立下 flag
|
||
flag = True
|
||
while flag:
|
||
|
||
# 如果栈顶是语义动作
|
||
if isinstance(stack.top(), SemanticRule):
|
||
stack.top().execute()
|
||
if len(stack.top().errors) > 0:
|
||
self.__error = stack.top().errors[-1]
|
||
break
|
||
else:
|
||
stack.pop()
|
||
# 如果栈顶是符号
|
||
else:
|
||
# 如果 top 是非终结符
|
||
if stack.top().data.is_non_terminal_sign():
|
||
# 查看分析表
|
||
production = self.__pa_table.get_production(stack.top().data, inputs[input_index])
|
||
# 如果分析表对应位置存有产生式
|
||
if production:
|
||
# 判断语义规则是否合法
|
||
if len(production.right) != len(production.semantic_children):
|
||
self.__error = SemanticRuleError('语义规则数量与产生式右边数量不一致 ' + production.str)
|
||
break
|
||
|
||
# 执行 start 语义
|
||
semantic_start = SemanticRuleFactory.get_instance(production.semantic_start, stack.top())
|
||
if semantic_start:
|
||
semantic_start.execute()
|
||
if len(semantic_start.errors) > 0:
|
||
self.__error = semantic_start.errors[-1]
|
||
break
|
||
|
||
# 将语法树按照产生式进行生长
|
||
for i in range(0, len(production.right)):
|
||
stack.top().children.append(Node(Sign(production.right[i].type)))
|
||
stack.top().children[i].parent = stack.top()
|
||
|
||
# 将 top 出栈
|
||
top = stack.pop()
|
||
|
||
# 将 end 语义规则入栈
|
||
semantic_end = SemanticRuleFactory.get_instance(production.semantic_end, top)
|
||
if semantic_end:
|
||
stack.push(semantic_end)
|
||
|
||
# 将 top 的孩子节点反序入栈
|
||
for i in range(len(production.right) - 1, -1, -1):
|
||
# for child in top.children[::-1]:
|
||
stack.push(top.children[i])
|
||
semantic_child = SemanticRuleFactory.get_instance(production.semantic_children[i],
|
||
top.children[i])
|
||
if semantic_child:
|
||
stack.push(semantic_child)
|
||
# 如果分析表中存放着错误信息
|
||
else:
|
||
self.__error = SyntaxError('语法错误 ' + inputs[input_index].str, inputs[input_index].line)
|
||
break
|
||
# 如果 top 是终结符
|
||
else:
|
||
# 如果 top = input
|
||
if stack.top().data.type == inputs[input_index].type:
|
||
# 如果 top = #，宣布分析成功
|
||
if stack.top().data.type == 'pound':
|
||
flag = False
|
||
# 如果 top != #
|
||
else:
|
||
# 计算 top 的 lexical 属性
|
||
stack.top().lexical = inputs[input_index].str
|
||
# 将 top 出栈，让 input_index 自增
|
||
stack.pop()
|
||
input_index += 1
|
||
# 如果 top != input
|
||
else:
|
||
self.__error = SyntaxError('语法错误 ' + inputs[input_index].str, inputs[input_index].line)
|
||
break
|
||
|
||
if self.__error:
|
||
return False
|
||
else:
|
||
self.__grammar_tree = grammar_tree
|
||
|
||
return True
|