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