添加expression语义

.gitignore

@@ -1,2 +1,3 @@
 __pycache__/
-.vscode/
+.vscode/
+*.csv

main.py

@@ -7,6 +7,10 @@ from syntax.syntax import LL1Generator
 
 # print(PredictingAnalysisTable().compile())
 
+# obj = LL1Generator()
+# obj.compile()
+# obj.show_me_what_you_got("LL1Table_id_2.csv",show_by_id=False)
+
 # 新建词法分析器
 lexical = Lexical()
 # 载入源代码

semantic/rule.py

@@ -299,6 +299,155 @@ class SemanticRuleFactory:
             return LocalDefineFollow31C2(node)
         if rule_key == 'LocalDefineFollow31E':
             return LocalDefineFollow31E(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':
@@ -954,18 +1103,458 @@ class Exp52E(SemanticRule):
     def __rule(self, node):
         node.bool = node.children[1].bool
         if node.children[1].bool:
-            node.name_1 = get_temp_var_name()
-            node.name_2 = get_temp_var_name()
+            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("(" + node.children[1].op + " ,", + node.children[0].name + " ," + node.children[1].name + " ," + node.name_1 + ")")
+            node.code.append("(" + node.children[1].op + " ,", + node.children[0].name + " ," + node.children[1].name + " ," + name_1 + ")")
             # (=. i1, _, o1)
-            node.code.append("(=, " + node.name_1 + ", _," + node.name_2 + ")")
+            node.code.append("(=, " + 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("(" + 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[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("(" + 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[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("(=, " + 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("(=[], " + node.id, + ", " + node.children[0].name + ", " + node.name)
+
+        else:
+            self.errors.append('变量' + 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('调用函数' + 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('函数' + 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("(param, _, _, )" + node.children[0].name)
+        for name in node.children[1].names:
+            node.code.append("(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()

syntax/rule.py

@@ -563,90 +563,90 @@ productions = [
     # 52
     Production('exp', ['additive-expr', 'exp-follow'],
                None, ['Exp52C0', 'Exp52C1'], 'Exp52E'),
-    # # 53
-    # Production('exp-follow', ['rel-op', 'additive-expr'],
-    #            None, [None, 'expFollow0C1'], 'expFollow0E'),
-    # # 54
-    # Production('exp-follow', [],
-    #            None, [], 'expFollow1E'),
-    # # 55
-    # Production('rel-op', ['smaller-equal'],
-    #            None, [None], 'RelOp0E'),
-    # # 56
-    # Production('rel-op', ['smaller'],
-    #            None, [None], 'RelOp1E'),
-    # # 57
-    # Production('rel-op', ['bigger'],
-    #            None, [None], 'RelOp2E'),
-    # # 58
-    # Production('rel-op', ['bigger-equal'],
-    #            None, [None], 'RelOp3E'),
-    # # 59
-    # Production('rel-op', ['equal'],
-    #            None, [None], 'RelOp4E'),
-    # # 60
-    # Production('rel-op', ['not-equal'],
-    #            None, [None], 'RelOp5E'),
-    # # 61
-    # Production('additive-expr', ['term', 'additive-expr-follow'],
-    #            None, ['AdditiveExpr0C0', 'AdditiveExpr0C1'], 'AdditiveExpr0E'),
-    # # 62
-    # Production('additive-expr-follow', ['add-op', 'term', 'additive-expr-follow'],
-    #            None, [None, 'AdditiveExprFollow0C1', 'AdditiveExprFollow0C2'], 'AdditiveExprFollow0E'),
-    # # 63
-    # Production('additive-expr-follow', [],
-    #            None, [], 'AdditiveExprFollow1E'),
-    # # 64
-    # Production('add-op', ['addition'],
-    #            None, [None], 'AddOp0E'),
-    # # 65
-    # Production('add-op', ['subtraction'],
-    #            None, [None], 'AddOp1E'),
-    # # 66
-    # Production('term', ['factor', 'term-follow'],
-    #            None, ['Term0C0', 'Term0C1'], 'Term0E'),
-    # # 67
-    # Production('term-follow', ['mul-op', 'factor', 'term-follow'],
-    #            None, [None, 'TermFollow0C1', 'TermFollow0C2'], 'TermFollow0E'),
-    # # 68
-    # Production('term-follow', [],
-    #            None, [], None),
-    # # 69
-    # Production('mul-op', ['multiplication'],
-    #            None, [None], 'MulOp0E'),
-    # # 70
-    # Production('mul-op', ['division'],
-    #            None, [None], 'MulOp1E'),
-    # # 71
-    # Production('factor', ['left-parentheses', 'exp', 'right-parentheses'],
-    #            None, [None, 'Factor0C1', None], 'Factor0E'),
-    # # 72
-    # Production('factor', ['id', 'id-factor-follow'],
-    #            None, [None, 'Factor1C1'], 'Factor1E'),
-    # # 73
-    # Production('factor', ['num'],
-    #            None, [None], 'Factor2E'),
-    # # 74
-    # Production('id-factor-follow', ['var-follow'],
-    #            None, [None], 'IdFactorFollow0E'),
-    # # 75
-    # Production('id-factor-follow', ['left-parentheses', 'args', 'right-parentheses'],
-    #            None, [None, 'IdFactorFollow1C1', None], 'IdFactorFollow1E'),
-    # # 76
-    # Production('args', ['arg-list'],
-    #            None, ['Args0C0'], 'Args0E'),
-    # # 77
-    # Production('args', [],
-    #            None, [], 'Args1E'),
-    # # 78
-    # Production('arg-list', ['exp', 'arg-list-follow'],
-    #            None, ['ArgList0C0', 'ArgList0C1'], 'ArgList0E'),
-    # # 79
-    # Production('arg-list-follow', ['comma', 'exp', 'arg-list-follow'],
-    #            None, [None, 'ArgListFollow0C1', 'ArgListFollow0C2'], 'ArgListFollow0E'),
-    # # 80
-    # Production('arg-list-follow', [],
-    #            None, [], 'ArgListFollow1E'),
+    # 53
+    Production('exp-follow', ['rel-op', 'additive-expr'],
+               None, [None, 'ExpFollow53C1'], 'ExpFollow53E'),
+    # 54
+    Production('exp-follow', [],
+               None, [], 'ExpFollow54E'),
+    # 55
+    Production('rel-op', ['smaller-equal'],
+               None, [None], 'RelOp55E'),
+    # 56
+    Production('rel-op', ['smaller'],
+               None, [None], 'RelOp56E'),
+    # 57
+    Production('rel-op', ['bigger'],
+               None, [None], 'RelOp57E'),
+    # 58
+    Production('rel-op', ['bigger-equal'],
+               None, [None], 'RelOp58E'),
+    # 59
+    Production('rel-op', ['equal'],
+               None, [None], 'RelOp59E'),
+    # 60
+    Production('rel-op', ['not-equal'],
+               None, [None], 'RelOp60E'),
+    # 61
+    Production('additive-expr', ['term', 'additive-expr-follow'],
+               None, ['AdditiveExpr61C0', 'AdditiveExpr61C1'], 'AdditiveExpr61E'),
+    # 62
+    Production('additive-expr-follow', ['add-op', 'term', 'additive-expr-follow'],
+               None, [None, 'AdditiveExprFollow62C1', 'AdditiveExprFollow62C2'], 'AdditiveExprFollow62E'),
+    # 63
+    Production('additive-expr-follow', [],
+               None, [], 'AdditiveExprFollow63E'),
+    # 64
+    Production('add-op', ['addition'],
+               None, [None], 'AddOp64E'),
+    # 65
+    Production('add-op', ['subtraction'],
+               None, [None], 'AddOp65E'),
+    # 66
+    Production('term', ['factor', 'term-follow'],
+               None, ['Term66C0', 'Term66C1'], 'Term66E'),
+    # 67
+    Production('term-follow', ['mul-op', 'factor', 'term-follow'],
+               None, [None, 'TermFollow67C1', 'TermFollow67C2'], 'TermFollow67E'),
+    # 68
+    Production('term-follow', [],
+               None, [], 'TermFollow68E'),
+    # 69
+    Production('mul-op', ['multiplication'],
+               None, [None], 'MulOp69E'),
+    # 70
+    Production('mul-op', ['division'],
+               None, [None], 'MulOp70E'),
+    # 71
+    Production('factor', ['left-parentheses', 'exp', 'right-parentheses'],
+               None, [None, 'Factor71C1', None], 'Factor71E'),
+    # 72
+    Production('factor', ['id', 'id-factor-follow'],
+               None, [None, 'Factor72C1'], 'Factor72E'),
+    # 73
+    Production('factor', ['num'],
+               None, [None], 'Factor73E'),
+    # 74
+    Production('id-factor-follow', ['var-follow'],
+               None, [None], 'IdFactorFollow74E'),
+    # 75
+    Production('id-factor-follow', ['left-parentheses', 'args', 'right-parentheses'],
+               None, [None, 'IdFactorFollow75C1', None], 'IdFactorFollow75E'),
+    # 76
+    Production('args', ['arg-list'],
+               None, ['Args76C0'], 'Args76E'),
+    # 77
+    Production('args', [],
+               None, [], 'Args77E'),
+    # 78
+    Production('arg-list', ['exp', 'arg-list-follow'],
+               None, ['ArgList78C0', 'ArgList78C1'], 'ArgList78E'),
+    # 79
+    Production('arg-list-follow', ['comma', 'exp', 'arg-list-follow'],
+               None, [None, 'ArgListFollow79C1', 'ArgListFollow79C2'], 'ArgListFollow79E'),
+    # 80
+    Production('arg-list-follow', [],
+               None, [], 'ArgListFollowE'),
     
     # 81
     Production('arraylist-with-num', [],

syntax/syntax.py

@@ -424,7 +424,7 @@ class Syntax:
                 # 如果 top 是非终结符
                 if stack.top().data.is_non_terminal_sign():
                     # 查看分析表
-                    print(stack.top().data.type,inputs[input_index].type)
+                    # print(stack.top().data.type,inputs[input_index].type)
                     production = self.__pa_table.get_production(stack.top().data.type, inputs[input_index].type)
                     # 如果分析表对应位置存有产生式
                     if production:

test9.c

@@ -1,5 +1,5 @@
 fn main(a:i32[], b:i32, c:f32[], d:i32) -> f32 {
-    i32 d;
+    i32 test;
 }
     
 fn demo() {