from semantic.symbol import * from error import SemanticError from semantic.code import get_temp_block_name, get_temp_var_name # 定义一个符号表池,每次调用函数的时候使用深拷贝从这里取局部变量表 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) # 22 if rule_key == 'CodeBlock22C0': return CodeBlock22C0(node) if rule_key == 'CodeBlock22E': return CodeBlock22E(node) # 23 if rule_key == 'CodeList23C0': return CodeList23C0(node) if rule_key == 'CodeList23C1': return CodeList23C1(node) if rule_key == 'CodeList23E': return CodeList23E(node) # 24 if rule_key == 'CodeList24E': return CodeList24E(node) # 25 if rule_key == 'Code25C0': return Code25C0(node) if rule_key == 'Code25E': return Code25E(node) # 26 if rule_key == 'Code26C0': return Code26C0(node) if rule_key == 'Code26E': return Code26E(node) # 27 if rule_key == 'Code27C0': return Code27C0(node) if rule_key == 'Code27E': return Code27E(node) # 28 if rule_key == 'Code28C0': return Code28C0(node) if rule_key == 'Code28E': return Code28E(node) # 29 if rule_key == 'Code29C0': return Code29C0(node) if rule_key == 'Code29E': return Code29E(node) # 30 if rule_key == 'LocalDefine30C0': return LocalDefine30C0(node) if rule_key == 'LocalDefine30C1': return LocalDefine30C1(node) if rule_key == 'LocalDefine30C2': return LocalDefine30C2(node) if rule_key == 'LocalDefine30C3': return LocalDefine30C3(node) if rule_key == 'LocalDefine30E': return LocalDefine30E(node) # 31 if rule_key == 'LocalDefineFollow31C1': return LocalDefineFollow31C1(node) if rule_key == 'LocalDefineFollow31C2': return LocalDefineFollow31C2(node) if rule_key == 'LocalDefineFollow31E': return LocalDefineFollow31E(node) # 34 if rule_key == 'NormalStatement34C1': return NormalStatement34C1(node) if rule_key == 'NormalStatement34E': return NormalStatement34E(node) # 35 if rule_key == 'NormalStatementFollow35C0': return NormalStatementFollow35C0(node) if rule_key == 'NormalStatementFollow35C2': return NormalStatementFollow35C2(node) if rule_key == 'NormalStatement35E': return NormalStatement35E(node) # 36 if rule_key == 'NormalStatementFollow36C0': return NormalStatementFollow36C0(node) if rule_key == 'NormalStatementFollow36E': return NormalStatementFollow36E(node) # 37 if rule_key == 'VarFollow37E': return VarFollow37E(node) # 38 if rule_key == 'VarFollow38E': return VarFollow38E(node) # 39 if rule_key == 'CallFollow39C1': return CallFollow39C1(node) if rule_key == 'CallFollow39E': return CallFollow39E(node) # 40 if rule_key == 'CallParams40C0': return CallParams40C0(node) if rule_key == 'CallParams40E': return CallParams40E(node) # 41 if rule_key == 'CallParams41E': return CallParams41E(node) # 42 if rule_key == 'CallParamList42C0': return CallParamList42C0(node) if rule_key == 'CallParamList42E': return CallParamList42E(node) # 43 if rule_key == 'CallParamFollow43C1': return CallParamFollow43C1(node) if rule_key == 'CallParamFollow43E': return CallParamFollow43E(node) # 44 if rule_key == 'CallParamFollow44E': return CallParamFollow44E(node) # 45 if rule_key == 'SelectionStatement45C1': return SelectionStatement45C1(node) if rule_key == 'SelectionStatement45C3': return SelectionStatement45C3(node) if rule_key == 'SelectionStatement45C5': return SelectionStatement45C5(node) if rule_key == 'SelectionStatement45E': return SelectionStatement45E(node) # 46 if rule_key == 'SelectionFollow46C2': return SelectionFollow46C2(node) if rule_key == 'SelectionFollow46E': return SelectionFollow46E(node) # 47 if rule_key == 'SelectionFollow47E': return SelectionFollow47E(node) # 48 if rule_key == 'IterationStatement48C1': return IterationStatement48C1(node) if rule_key == 'IterationStatement48C3': return IterationStatement48C3(node) if rule_key == 'IterationStatement48E': return IterationStatement48E(node) # 49 if rule_key == 'ReturnStatement49C1': return ReturnStatement49C1(node) if rule_key == 'ReturnStatement49E': return ReturnStatement49E(node) # 50 if rule_key == 'ReturnFollow50E': return ReturnFollow50E(node) # 51 if rule_key == 'ReturnFollow51C0': return ReturnFollow51C0(node) if rule_key == 'ReturnFollow51E': return ReturnFollow51E(node) # 52 if rule_key == 'Exp52C0': return Exp52C0(node) if rule_key == 'Exp52C1': return Exp52C1(node) if rule_key == 'Exp52E': return Exp52E(node) # 53 if rule_key == 'ExpFollow53C1': return ExpFollow53C1(node) if rule_key == 'ExpFollow53E': return ExpFollow53E(node) # 54 if rule_key == 'ExpFollow54E': return ExpFollow54E(node) # 55 if rule_key == 'RelOp55E': return RelOp55E(node) # 56 if rule_key == 'RelOp56E': return RelOp56E(node) # 57 if rule_key == 'RelOp57E': return RelOp57E(node) # 58 if rule_key == 'RelOp58E': return RelOp58E(node) # 59 if rule_key == 'RelOp59E': return RelOp59E(node) # 60 if rule_key == 'RelOp60E': return RelOp60E(node) # 61 if rule_key == 'AdditiveExpr61C0': return AdditiveExpr61C0(node) if rule_key == 'AdditiveExpr61C1': return AdditiveExpr61C1(node) if rule_key == 'AdditiveExpr61E': return AdditiveExpr61E(node) # 62 if rule_key == 'AdditiveExprFollow62C1': return AdditiveExprFollow62C1(node) if rule_key == 'AdditiveExprFollow62C2': return AdditiveExprFollow62C2(node) if rule_key == 'AdditiveExprFollow62E': return AdditiveExprFollow62E(node) # 63 if rule_key == 'AdditiveExprFollow63E': return AdditiveExprFollow63E(node) # 64 if rule_key == 'AddOp64E': return AddOp64E(node) # 65 if rule_key == 'AddOp65E': return AddOp65E(node) # 66 if rule_key == 'Term66C0': return Term66C0(node) if rule_key == 'Term66C1': return Term66C1(node) if rule_key == 'Term66E': return Term66E(node) # 67 if rule_key == 'TermFollow67C1': return TermFollow67C1(node) if rule_key == 'TermFollow67C2': return TermFollow67C2(node) if rule_key == 'TermFollow67E': return TermFollow67E(node) # 68 if rule_key == 'TermFollow68E': return TermFollow68E(node) # 69 if rule_key == 'MulOp69E': return MulOp69E(node) # 70 if rule_key == 'MulOp70E': return MulOp70E(node) # 71 if rule_key == 'Factor71C1': return Factor71C1(node) if rule_key == 'Factor71E': return Factor71E(node) # 72 if rule_key == 'Factor72C1': return Factor72C1(node) if rule_key == 'Factor72E': return Factor72E(node) # 73 if rule_key == 'Factor73E': return Factor73E(node) # 74 if rule_key == 'IdFactorFollow74E': return IdFactorFollow74E(node) # 75 if rule_key == 'IdFactorFollow75C1': return IdFactorFollow75C1(node) if rule_key == 'IdFactorFollow75E': return IdFactorFollow75E(node) # 76 if rule_key == 'Args76C0': return Args76C0(node) if rule_key == 'Args76E': return Args76E(node) # 77 if rule_key == 'Args77E': return Args77E(node) # 78 if rule_key == 'ArgList78C0': return ArgList78C0(node) if rule_key == 'ArgList78C1': return ArgList78C1(node) if rule_key == 'ArgList78E': return ArgList78E(node) # 79 if rule_key == 'ArgListFollow79C1': return ArgListFollow79C1(node) if rule_key == 'ArgListFollow79C2': return ArgListFollow79C2(node) if rule_key == 'ArgListFollow79E': return ArgListFollow79E(node) # 80 if rule_key == 'ArgListFollow80E': return ArgListFollow80E(node) # 81 if rule_key == 'ArrayListWithNum81E': return ArrayListWithNum81E(node) # 82 if rule_key == 'ArrayListWithNum82E': return ArrayListWithNum82E(node) # 84 if rule_key == 'MulOp84E': return MulOp84E(node) return None 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) 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.get_pre_brother(6).lexical 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 CodeBlock22C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class CodeBlock22E(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 Code25C0(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 Code26C0(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 Code27C0(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 Code28C0(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 Code29C0(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) class LocalDefine30C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class LocalDefine30C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class LocalDefine30C2(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class LocalDefine30C3(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 LocalDefine30E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.id = node.children[2].lexical if symbol_table_pool.query(node.fun).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.query(node.fun).append( LocalVar(node.id, 'i32[]', 4 * node.length, False) ) if node.children[1].type == 'var': node.type = 'i32' symbol_table_pool.query(node.fun).append( LocalVar(node.id, 'i32', 4, False) ) 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.query(node.fun).append( LocalVar(node.id, 'f32[]', 4 * node.length, False) ) if node.children[1].type == 'var': node.type = 'f32' symbol_table_pool.query(node.fun).append( LocalVar(node.id, 'f32', 4, False) ) if node.type == None: self.errors.append(SemanticError('变量' + node.get_pre_brother(1).lexical + '声明类型不支持')) class LocalDefineFollow31C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class LocalDefineFollow31C2(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun node.type = node.parent.type node.length = node.parent.length class LocalDefineFollow31E(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)) ) # 32 pass # 33 pass # 34 class NormalStatement34C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.id = node.get_pre_brother(1).lexical node.fun = node.parent.fun class NormalStatement34E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[1].code: node.code.append(c) # 35 class NormalStatementFollow35C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun node.id = node.parent.id class NormalStatementFollow35C2(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class NormalStatement35E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): if node.children[0].type=='var': for c in node.children[2].code: node.code.append(c) node.code.append(f"(=, {node.children[2].name} , _ , {node.id})") if node.children[0].type =='array': for c in node.children[0].code: node.code.append(c) for c in node.children[2].code: node.code.append(c) node.code.append(f"([]= , {node.children[2].name}, {node.children[0].id} , {node.children[0].name})") # 36 class NormalStatementFollow36C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun node.id = node.parent.id class NormalStatementFollow36E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[0].code: node.code.append(c) node.code.append(f"(call, {node.id}, {str(symbol_table_pool.query(node.id).get_params_num())}, _)") # 37 class VarFollow37E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.type = 'var' # 38 class VarFollow38E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.type = 'array' for c in node.children[1].code: node.code.append(c) node.name = node.children[1].name # 39 class CallFollow39C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun node.id = node.parent.id class CallFollow39E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): if symbol_table_pool.fun_table.exist(node.id): if node.children[1].num != symbol_table_pool.query(node.id).get_params_num(): self.errors.append(SemanticError(f"错误 : 调用函数{node.id}的参数与实际参数不匹配")) for c in node.children[1].code: node.code.append(c) else: self.errors.append(SemanticError(f"错误 : 调用函数{node.id}不存在")) # 40 class CallParams40E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.num = node.children[0].num for c in node.children[0].code: node.code.append(c) class CallParams40C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.id = node.parent.id node.fun = node.parent.fun # 41 class CallParams41E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.num = 0 # 42 class CallParamList42C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun node.id = node.parent.id class CallParamList42E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.num = 1 + node.children[1].num for c in node.children[0].code: node.code.append(c) for c in node.children[1].code: node.code.append(c) node.code.append(f"(param, _, _, {node.children[0].name})") for name in node.children[1].names: node.code.append(f"(param, _, _, {name})") # 43 class CallParamFollow43C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.id = node.parent.id node.fun = node.parent.fun class CallParamFollow43E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[1].code: node.code.append(c) for c in node.children[2].code: node.code.append(c) node.num = 1 + node.children[2].num node.names.append(node.children[1].name) for name in node.children[2].names: node.names.append(name) class CallParamFollow44E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.num = 0 node.code.clear() node.names.clear() class SelectionStatement45C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class SelectionStatement45C3(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class SelectionStatement45C5(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun # 45 class SelectionStatement45E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): if not node.children[1].bool: self.errors.append(SemanticError('if判断中的表达式不是bool表达式')) else: for c in node.children[1].code: node.code.append(c) if_block = get_temp_block_name() else_block = get_temp_block_name() next_block = get_temp_block_name() node.code.append(f"(if, {node.children[1].name}, goto, {if_block})") node.code.append(f"(block, _, _, {if_block})") for c in node.children[3].code: node.code.append(c) node.code.append(f"(goto, _, _, {next_block})") node.code.append(f"(block, _, _, {else_block})") for c in node.children[5].code: node.code.append(c) node.code.append(f"(goto, _, _, {next_block})") node.code.append(f"(block, _, _, {next_block})") class SelectionFollow46C2(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class SelectionFollow46E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[2].code: node.code.append(c) class SelectionFollow47E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.code.clear() class IterationStatement48C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class IterationStatement48C3(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class IterationStatement48E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): judge_block = get_temp_block_name() iteration_block = get_temp_block_name() next_block = get_temp_block_name() node.code.append(f"(block, _, _, {judge_block})") for c in node.children[1].code: node.code.append(c) node.code.append(f"(if, {node.children[1].name}, goto, {iteration_block})") node.code.append(f"(goto, _, _, {next_block})") node.code.append(f"(block, _, _, {iteration_block})") for c in node.children[3].code: node.code.append(c) node.code.append(f"(goto, _, _, {judge_block})") node.code.append(f"(block, _, _, {next_block})") class ReturnStatement49C1(SemanticRule): def execute(self): return self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class ReturnStatement49E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[1].code: node.code.append(c) class ReturnFollow50E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.code.append("(return, _, _, _)") class ReturnFollow51C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class ReturnFollow51E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[0].code: node.code.append(c) node.code.append(f"(return, _, _, {node.children[0].name})") class Exp52C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class Exp52C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class Exp52E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.bool = node.children[1].bool if node.children[1].bool: name_1 = get_temp_var_name() node.name = get_temp_var_name() for c in node.children[0].code: node.code.append(c) for c in node.children[1].code: node.code.append(c) # (op, i1, i2, o1) node.code.append(f"({node.children[1].op}, {node.children[0].name}, {node.children[1].name}, {name_1})") # (=. i1, _, o1) node.code.append(f"(=, {name_1}, _, {node.name})") else: node.name = node.children[0].name for c in node.children[0].code: node.code.append(c) class ExpFollow53C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class ExpFollow53E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.bool = True node.op = node.children[0].op node.name = node.children[1].name for c in node.children[1].code: node.code.append(c) class ExpFollow54E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.bool = False class RelOp55E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.op = node.children[0].lexical class RelOp56E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.op = node.children[0].lexical class RelOp57E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.op = node.children[0].lexical class RelOp58E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.op = node.children[0].lexical class RelOp59E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.op = node.children[0].lexical class RelOp60E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.op = node.children[0].lexical class AdditiveExpr61C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class AdditiveExpr61C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class AdditiveExpr61E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): if node.children[1].add: name_1 = get_temp_var_name() node.name = get_temp_var_name() for c in node.children[0].code: node.code.append(c) for c in node.children[1].code: node.code.append(c) # (op, in1, in2, o1) node.code.append(f"({node.children[1].op}, {node.children[0].name}, {node.children[1].name}, {name_1})") # (=, in1, _, o1) node.code.append(f"(=, {name_1}, _, {node.name})") else: node.name = node.children[0].name for c in node.children[0].code: node.code.append(c) class AdditiveExprFollow62C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class AdditiveExprFollow62C2(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class AdditiveExprFollow62E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.add = True node.op = node.children[0].op if node.children[2].add: node.name = get_temp_var_name() name_1 = get_temp_var_name() for c in node.children[1].code: node.code.append(c) for c in node.children[2].code: node.code.append(c) # (op, in1, in2, o1) node.code.append("(" + node.children[1].op + ", " + node.children[0].name + ", " + node.children[1].name + ", " + name_1 + ")") # (=, in1, _, o1) node.code.append("(=, " + name_1, + ", _, " + node.name + ")") else: node.name = node.children[1].name for c in node.children[1].code: node.code.append(c) class AdditiveExprFollow63E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.add = False; class AddOp64E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.op = node.children[0].lexical class AddOp65E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.op = node.children[0].lexical class Term66C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class Term66C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class Term66E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): if node.children[1].mul: name_1 = get_temp_var_name() node.name = get_temp_var_name() for c in node.children[0].code: node.code.append(c) for c in node.children[1].code: node.code.append(c) # (op, in1, in2, o1) node.code.append(f"({node.children[1].op}, {node.children[0].name}, {node.children[1].name}, {name_1})") # (=, in1, _, o1) node.code.append(f"(=, {name_1}, _, {node.name})") else: node.name = node.children[0].name for c in node.children[0].code: node.code.append(c) class TermFollow67C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class TermFollow67C2(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class TermFollow67E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.mul = True node.op = node.children[0].op if node.children[2].mul: node.name = get_temp_var_name() name_1 = get_temp_var_name() for c in node.children[1].code: node.code.append(c) for c in node.children[2].code: node.code.append(c) # (op, in1, in2, o1) node.code.append("(" + node.children[1].op + ", " + node.children[0].name + ", " + node.children[1].name + ", " + name_1 + ")") # (=, in1, _, o1) node.code.append("(=, " + name_1, + ", _, " + node.name + ")") else: node.name = node.children[1].name for c in node.children[1].code: node.code.append(c) class TermFollow68E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.mul = False; class MulOp69E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.op = node.children[0].lexical class MulOp70E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.op = node.children[0].lexical class Factor71C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class Factor71E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[1].code: node.code.append(c) node.name = node.children[1].name class Factor72C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.id = node.get_pre_brother(1).lexical node.fun = node.parent.fun class Factor72E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[1].code: node.code.append(c) node.name = node.children[1].name class Factor73E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.name = get_temp_var_name() node.code.append(f"(=, {node.children[0].lexical}, _, {node.name})") class IdFactorFollow74E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): if symbol_table_pool.query(node.fun).exist(node.id): if node.children[0].type == "var": node.name = node.id if node.children[0].type == "array": node.name = get_temp_var_name() for c in node.children[0].code: node.code.append(c) node.code.append(f"(=[], {node.id}, {node.children[0].name}, {node.name})") else: self.errors.append(SemanticError('变量' + node.id + '未定义')) class IdFactorFollow75C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class IdFactorFollow75E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): if symbol_table_pool.fun_table.exist(node.id): if node.children[1].num != symbol_table_pool.query(node.id).get_params_num(): self.errors.append(SemanticError('调用函数' + node.id + ', 参数数量不匹配')) else: for c in node.children[1].code: node.code.append(c) node.code.append('(call' + ', ' + node.id + ', ' + str(symbol_table_pool.query(node.id).get_params_num()) + ", _)") node.name = get_temp_var_name() node.code.append('(=, result, _, ' + node.name + ')') else: self.errors.append(SemanticError('函数' + node.id + '未定义')) class Args76C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class Args76E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): for c in node.children[0].code: node.code.append(c) node.num = node.children[0].num class Args77E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.code.clear() node.num = 0 class ArgList78C0(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class ArgList78C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class ArgList78E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.num = 1 + node.children[1].num for c in node.children[0].code: node.code.append(c) for c in node.children[1].code: node.code.append(c) node.code.append(f"(param, _, _, {node.children[0].name})") for name in node.children[1].names: node.code.append(f"(param, _, _, {name})") class ArgListFollow79C1(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class ArgListFollow79C2(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.fun = node.parent.fun class ArgListFollow79E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.num = 1 + node.children[2].num for c in node.children[1].code: node.code.append(c) for c in node.children[2].code: node.code.append(c) node.names.append(node.children[1].name) for name in node.children[2].names: node.names.append(name) class ArgListFollow80E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.num = 0 node.code.clear() node.names.clear() class Factor83E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.name = get_temp_var_name() node.code.append("(=, " + node.children[0].lexical, +", _, ", node.name) class MulOp84E(SemanticRule): def execute(self): self.__rule(self.node) def __rule(self, node): node.op = node.children[0].lexical