修改了浮点数的词法分析

Optimizer/Optimizer.py

@@ -0,0 +1,56 @@
+from block import *
+
+def tp(sth):
+    try:
+        a = float(sth)
+        return 2
+    except:
+        if sth[0] == '_':
+            return 0
+        return 1
+
+class DAGNode:
+    cnt = 1
+    def __init__(self,tag,l=None,r=None,op=None):
+        self.cnt = DAGNode.cnt
+        DAGNode.cnt += 1
+        self.parents = []
+        self.lc = l
+        self.rc = r
+        self.op = op
+        self.main_tag = tag
+        self.other_tag = set(tag)
+
+
+class Optimizer:
+    def __init__(self):
+        self.DAGNodes = set()
+    def optimize(self, lst):
+        # print(lst)
+        self.build(lst)
+        return [1]
+    def insert(self,a,b):
+        pass
+
+    def build(self, lst):
+        for i in lst:
+            op = i.a
+            l = i.b
+            r = i.c
+            ans = i.d
+            if op == '=':
+                pass
+
+
+
+if __name__ == '__main__':
+    divider = BlockDivider(l)
+    optimizer = Optimizer()
+    ls = divider.run()
+    
+    for l in ls:
+        # print(l)
+        ans = optimizer.optimize(l)
+        for _ in ans:
+            print(_)
+        print()

Optimizer/block.py

@@ -0,0 +1,52 @@
+l = [
+    "=,10,_,t1",
+    "=,20,_,t1",
+    "+,t1,t1,t2"
+]
+class FourTuple:
+    cnt =0
+    def __init__(self, a='_',b='_',c='_',d='_'):
+        self.a = a
+        self.b = b
+        self.c = c
+        self.d = d
+        self.cnt = FourTuple.cnt
+        FourTuple.cnt += 1
+        self.block_sign = set(['if','jmp','jmpf','el','ifend','while','fun','return','while','we','goto'])
+
+
+    def is_block_sign(self):
+        return self.a in self.block_sign
+    def __str__(self):
+        return f"({self.a} , {self.b} , {self.c} , {self.d})"
+class BlockDivider:
+    def __init__(self,lst):
+        self.ans = []
+        self.l =[]
+        for i in lst:
+            k = i.split(',')
+            obj = FourTuple(k[0].strip(),k[1].strip(),k[2].strip(),k[3].strip())
+            self.l.append(obj)
+            # print(obj)
+    def run(self):
+        lst = []
+        for i in self.l:
+            lst.append(i)
+            if i.is_block_sign():
+                self.ans.append(lst)
+                lst = []
+        if lst:
+            self.ans.append(lst)
+
+        return self.ans
+
+
+
+if __name__ == '__main__':
+
+    divider = BlockDivider(l)
+    ans = divider.run()
+    for i in ans:
+        for j in i:
+            print(j,end='\t')
+        print()

lexical/rule.py

@@ -83,7 +83,6 @@ regex_dict = {
     'left-brace': r'\{',
     'right-brace': r'\}',
     'id': r'[a-zA-Z][a-zA-Z]*',
-    'float-num': r'^.*?([0-9]*\.[0-9]+|[0-9]+[eE][+-]?[0-9]+).*$',
+    'float-num': r'\d+\.\d+[eE][+-]\d+|\d+\.\d+|\d+[eE][+-]\d+',
     'int-num': r'[1-9][0-9]*|0',
-
 }