from semantic.symbol import * from error import SemanticError from semantic.code import get_temp_block_name, get_temp_var_name """ 添加语义规则的文法 0. program{code} ->{.init} define-list 1. define-list{code} -> define define-list {code} | empty 2. define{code} -> type ID define-type{type id} 3. define-type{code .enter} ->{.judge} var-define-follow{type id} {code} |{.judge} fun-define-follow{type fun} 4. var-define-follow{type} -> ; {type length} | [ NUM ] ; 5. type ->{type} int |{type} void 6. fun-define-follow{code} -> ( params{type fun} ) code-block{fun} 7. params{.create} -> param-list{fun} {.create} | empty 8. param-list -> param{fun} param-follow{fun} 9. param-follow -> , param{fun} param-follow{fun} | empty 10. param -> type ID array-subscript 11. array-subscript{type} -> [ ] {type} | empty 12. code-block{code} -> { local-define-list{fun} code-list{fun} } 13. local-define-list -> local-var-define{fun} local-define-list{fun} | empty 14. local-var-define -> type ID var-define-follow 15. code-list{code} -> code{fun} code-list{fun} | empty 16. code{code} -> normal-statement{fun} | selection-statement{fun} | iteration-statement{fun} | return-statement{fun} 17. normal-statement -> ; | ID normal-statement-follow{fun id} 18. normal-statement-follow{code} -> var-follow{fun} = expression{fun} ; {code} | call-follow{fun id} ; 19. call-follow{code} -> ( call-params{fun id} ) 20. call-params{code} -> call-param-list{fun} | empty 21. call-param-list{num code} -> expression{fun} call-param-follow{fun} 22. call-param-follow{num code names} -> , expression{fun} call-param-follow{fun} | empty 23. selection-statement{code} -> if ( expression{fun} ) { code-list{fun} } selection-follow{fun} 24. selection-follow{code} -> else { code-list{fun} } {code} | empty 25. iteration-statement -> while ( expression{fun} ) iteration-follow{fun} 26. iteration-follow{code} -> { code-list{fun} } {code} | code{fun} 27. return-statement{code} -> return return-follow{fun} 28. return-follow -> ; | expression{fun} ; 29. var-follow{code name type} -> [ expression{fun} ] {type} | empty 30. expression{code name bool} -> additive-expr{fun} expression-follow{fun} 31. expression-follow{bool code op name} -> rel-op additive-expr{fun} {bool} | empty 32. rel-op{op} -> <= | < | > | >= | == | != 33. additive-expr{name code} -> term{fun} additive-expr-follow{fun} 34. additive-expr-follow{add op code name} -> add-op term{fun} additive-expr-follow{fun} {add} | empty 35. add-op{op} -> + | - 36. term{name code} -> factor{fun} term-follow{fun} 37. term-follow{mul op code name} -> mul-op factor{fun} term-follow{fun} {mul} | empty 38. mul-op{op} -> * | / | % 39. factor{name code} -> ( expression{fun} ) | ID id-factor-follow{id fun} | NUM 40. id-factor-follow -> var-follow{fun} | ( args{fun} ) 41. args{code num} -> arg-list{fun} | empty 42. arg-list{code num} -> expression{fun} arg-list-follow{fun} 43. arg-list-follow{code num names} -> , expression{fun} arg-list-follow{fun} | empty """ # 定义一个符号表池，每次调用函数的时候使用深拷贝从这里取局部变量表 symbol_table_pool = SymbolTablePool() class SemanticRule: """ 语义规则 """ def __init__(self, node): """ 构造 :param node: 树节点 """ self.node = node self.errors = list() def __rule(self, node): """ 实际的语义规则，需要复写 :param node: """ return [] def execute(self): """ 执行语义规则 """ self.__rule(self.node) def have_no_errors(self): """ 是否没有错误 :return: 是否没有错误 """ return len(self.errors) == 0 class SemanticRuleFactory: """ 语义规则工厂，根据给出的 rule_key 返回相应的实例 """ @classmethod def get_instance(cls, rule_key, node): """ 获取语义规则实例 :param rule_key: 关键字 :param node: 目标节点 :return: 实例 """ # 0 if rule_key == 'Program0S': return Program0S(node) if rule_key == 'Program0E': return Program0E(node) # 1 if rule_key == 'DefineLists1E': return DefineLists1E(node) # 2 if rule_key == 'DefineLists2E': return DefineLists2E(node) # 3 if rule_key == 'DefineList3E': return DefineList3E(node) # 4 if rule_key == 'DefineList4E': return DefineList4E(node) # 5 if rule_key == 'FunDefine5C3': return FunDefine5C3(node) if rule_key == 'FunDefine5C5': return FunDefine5C5(node) if rule_key == 'FunDefine5C7': return FunDefine5C7(node) if rule_key == 'FunDefine5E': return FunDefine5E(node) # 6 if rule_key == 'Params6S': return Params6S(node) # 7 if rule_key == 'Params7S': return Params7S(node) if rule_key == 'Params7C0': return Params7C0(node) # 8 if rule_key == 'ParamList8C0': return ParamList8C0(node) if rule_key == 'ParamList8C1': return ParamList8C1(node) # 9 if rule_key == 'ParamFollow9C1': return ParamFollow9C1(node) if rule_key == 'ParamFollow9C2': return ParamFollow9C2(node) # 11 if rule_key == 'Param11E': return Param11E(node) # 12 if rule_key == 'ArrayList12S': return ArrayList12S(node) # 13 if rule_key == 'ArrayList13S': return ArrayList13S(node) # 14 if rule_key == 'FunReturn14S': return FunReturn14S(node) # 15 if rule_key == 'FunReturn15E': return FunReturn15E(node) # 16 if rule_key == 'Type16S': return Type16S(node) # 17 if rule_key == 'Type17S': return Type17S(node) # 18 if rule_key == 'Type18S': return Type18S(node) # 19 if rule_key == 'GlobalVarDefine19C3': return GlobalVarDefine19C3(node) if rule_key == 'GlobalVarDefine19E': return GlobalVarDefine19E(node) # 20 if rule_key == 'GlobalVarDefineFllow20E': return GlobalVarDefineFllow20E(node) if rule_key == 'GlobalVarDefineFllow20C2': return GlobalVarDefineFllow20C2(node) # 81 if rule_key == 'ArrayListWithNum81E': return ArrayListWithNum81E(node) # 82 if rule_key == 'ArrayListWithNum82E': return ArrayListWithNum82E(node) return None # S 产生式开始 # E 产生式结束 # CN 产生式第N个元素应用之后 # 0 class Program0S(SemanticRule): def __rule(self, node): symbol_table_pool.init() def execute(self): self.__rule(self.node) class Program0E(SemanticRule): def __rule(self, node): for c in node.children[0].code: node.code.append(c) symbol_table_pool.debug() def execute(self): self.__rule(self.node) # 1 class DefineLists1E(SemanticRule): def __rule(self, node): for c in node.children[0].code: node.code.append(c) for c in node.children[1].code: node.code.append(c) def execute(self): self.__rule(self.node) # 2 class DefineLists2E(SemanticRule): def __rule(self, node): node.code.clear() def execute(self): self.__rule(self.node) # 3 class DefineList3E(SemanticRule): def __rule(self, node): for c in node.children[0].code: node.code.append(c) def execute(self): self.__rule(self.node) # 4 class DefineList4E(SemanticRule): def __rule(self, node): for c in node.children[0].code: node.code.append(c) def execute(self): self.__rule(self.node) # 5 class FunDefine5C3(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.parent.id = node.get_pre_brother(2).lexical if symbol_table_pool.fun_table.exist(node.parent.id): self.errors.append(SemanticError('函数名' + node.id + '重定义')) node.fun = node.parent.id class FunDefine5C5(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.id class FunDefine5C7(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.id class FunDefine5E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[3].code: node.code.append(c) for c in node.children[7].code: node.code.append(c) node.type = node.children[7].type class Params6S(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): symbol_table_pool.append( LocalVarTable(node.fun, symbol_table_pool.global_var_table) ) symbol_table_pool.fun_table.append( Fun(node.fun, None, symbol_table_pool.query(node.fun)) ) class Params7S(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): symbol_table_pool.append( LocalVarTable(node.fun, symbol_table_pool.global_var_table) ) symbol_table_pool.fun_table.append( Fun(node.fun, None, symbol_table_pool.query(node.fun)) ) class Params7C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class ParamList8C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class ParamList8C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class ParamFollow9C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class ParamFollow9C2(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class Param11E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): if node.children[2].type == 'void': self.errors.append(SemanticError('参数' + node.children[0].lexical + '不能定义为void类型')) if node.children[2].type == 'i32': if symbol_table_pool.query(node.fun).exist(node.children[0].lexical): self.errors.append(SemanticError('参数' + node.children[0].lexical + '重定义')) else: if node.children[3].type == 'array': symbol_table_pool.query(node.fun).append( LocalVar(node.children[0].lexical, 'address', 4, True) ) if node.children[3].type == 'var': symbol_table_pool.query(node.fun).append( LocalVar(node.children[0].lexical, 'i32', 4, True) ) if node.children[2].type == 'f32': if symbol_table_pool.query(node.fun).exist(node.children[0].lexical): self.errors.append(SemanticError('参数' + node.children[1].lexical + '重定义')) else: if node.children[3].type == 'array': symbol_table_pool.query(node.fun).append( LocalVar(node.children[0].lexical, 'address', 4, True) ) if node.children[3].type == 'var': symbol_table_pool.query(node.fun).append( LocalVar(node.children[0].lexical, 'f32', 4, True) ) class ArrayList12S(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.type = 'var' class ArrayList13S(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.type = 'array' class FunReturn14S(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.type = 'void' if not symbol_table_pool.change_fun_type(node.fun, node.type): self.errors.append(SemanticError('函数' + node.fun + '没有定义')) class FunReturn15E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): if node.children[1].type == 'void' and node.children[2].type =='var': if not symbol_table_pool.change_fun_type(node.fun, 'void'): self.errors.append(SemanticError('函数' + node.fun + '没有定义')) if node.children[1].type == 'void' and node.children[2].type =='array': if not symbol_table_pool.change_fun_type(node.fun, 'void[]'): self.errors.append(SemanticError('函数' + node.fun + '没有定义')) if node.children[1].type == 'i32': if node.children[2].type == 'array': if not symbol_table_pool.change_fun_type(node.fun, 'i32[]'): self.errors.append(SemanticError('函数' + node.fun + '没有定义')) if node.children[2].type == 'var': if not symbol_table_pool.change_fun_type(node.fun, 'i32'): self.errors.append(SemanticError('函数' + node.fun + '没有定义')) if node.children[1].type == 'f32': if node.children[2].type == 'array': if not symbol_table_pool.change_fun_type(node.fun, 'f32[]'): self.errors.append(SemanticError('函数' + node.fun + '没有定义')) if node.children[2].type == 'var': if not symbol_table_pool.change_fun_type(node.fun, 'f32'): self.errors.append(SemanticError('函数' + node.fun + '没有定义')) class Type16S(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.type = 'i32' class Type17S(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.type = 'f32' class Type18S(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.type = 'void' class GlobalVarDefine19C3(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.type = None node.length = 0 node.array = None if node.get_pre_brother(3).type == 'void' and node.get_pre_brother(2).type =='var': self.errors.append(SemanticError('变量' + node.id + '不能定义为void类型')) if node.get_pre_brother(3).type == 'void' and node.get_pre_brother(2).type =='array': self.errors.append(SemanticError('变量' + node.id + '不能定义为void[]类型')) if node.get_pre_brother(3).type == 'i32': if node.get_pre_brother(2).type == 'array': node.type = 'i32[]' node.length = node.get_pre_brother(2).length node.array = True if node.get_pre_brother(2).type == 'var': node.type = 'i32' node.array = False if node.get_pre_brother(3).type == 'f32': if node.get_pre_brother(2).type == 'array': node.type = 'f32[]' node.array = True node.length = node.get_pre_brother(2).length if node.get_pre_brother(2).type == 'var': node.type = 'f32' node.array = False if node.type == None: self.errors.append(SemanticError('变量' + node.get_pre_brother(1).lexical + '声明类型不支持')) class ArrayListWithNum82E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.type = 'array' node.length = node.children[1].lexical class ArrayListWithNum81E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.type = 'var' class GlobalVarDefine19E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.id = node.children[2].lexical if symbol_table_pool.global_var_table.exist(node.id): self.errors.append(SemanticError('变量' + node.id + '重定义')) node.type = None node.length = 0 if node.children[0].type == 'void' and node.children[1].type =='var': self.errors.append(SemanticError('变量' + node.id + '不能定义为void类型')) if node.children[0].type == 'void' and node.children[1].type =='array': self.errors.append(SemanticError('变量' + node.id + '不能定义为void[]类型')) if node.children[0].type == 'i32': if node.children[1].type == 'array': node.type = 'i32[]' node.length = int(node.children[1].length) symbol_table_pool.global_var_table.append( GlobalVar(node.id, 'i32[]', 4 * node.length) ) if node.children[1].type == 'var': node.type = 'i32' symbol_table_pool.global_var_table.append( GlobalVar(node.id, 'i32', 4) ) if node.children[0].type == 'f32': if node.children[1].type == 'array': node.type = 'f32[]' node.length = int(node.children[1].length) symbol_table_pool.global_var_table.append( GlobalVar(node.id, 'f32[]', 4 * node.length) ) if node.children[1].type == 'var': node.type = 'f32' symbol_table_pool.global_var_table.append( GlobalVar(node.id, 'f32', 4) ) if node.type == None: self.errors.append(SemanticError('变量' + node.get_pre_brother(1).lexical + '声明类型不支持')) class GlobalVarDefineFllow20C2(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.type = node.parent.type node.length = node.parent.length node.array = node.parent.array class GlobalVarDefineFllow20E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.id = node.children[1].lexical if symbol_table_pool.global_var_table.exist(node.id): self.errors.append(SemanticError('变量' + node.id + '重定义')) symbol_table_pool.global_var_table.append( GlobalVar(node.id, node.type, 4 * int(node.length)) ) class CodeList22C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class CodeList22E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.code.append("(fun, _, _, " + node.fun + ")") for c in node.children[0].code: node.code.append(c) class CodeList23C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class CodeList23C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class CodeList23E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[0].code: node.code.append(c) for c in node.children[1].code: node.code.append(c) class CodeList24E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.code.clear() class CodeList25C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class Code25E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[0].code: node.code.append(c) class CodeList26C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class Code26E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[0].code: node.code.append(c) class CodeList27C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class Code27E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[0].code: node.code.append(c) class CodeList28C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class Code28E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[0].code: node.code.append(c) class CodeList29C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class Code29E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[0].code: node.code.append(c)