1941 lines
56 KiB
Python
1941 lines
56 KiB
Python
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)
|
|
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.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 |