Optimizer/Optimizer.py

@@ -1,198 +1,195 @@
-#  优化模块
+from block import *
-# 第一步: 常量传播
+def is_f(s):
-def constant_propagation(quads):
+    return '.' in s or 'e' in s.lower()
-    #print("Running Constant Propagation")
+def tp(sth):
-    value_map = {}
+    if sth ==None:
-    optimized = []
+        return -1
+    if is_f(sth):
+        return 2
+    if sth[0] >='0' and sth[0] <='9':
+        return 2
+    if sth[0] != '_':
+        return 1
+    return 0
 
-    for quad in quads:
+def f(op,a,b):
-        op, arg1, arg2, dest = quad
+    if op =='+':
+        return float(a)+float(b)
+    elif op =='-':
+        return float(a)-float(b)
+    elif op =='*':
+        return float(a)*float(b)
+    elif op =='/':
+        return float(a)/float(b)
+    return 0
+class DAGNode:
+    cnt = 1
+    def __init__(self,tag=None,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()
+        if tag is not None:
+            self.other_tag.add(tag)
+    def insert(self,tag):
+        self.other_tag.add(tag)
+        if tp(tag) > tp(self.main_tag):
+            self.main_tag = tag
+    def has(self,tag):
+        return tag in self.other_tag
+class Optimizer:
+    def __init__(self):
+        self.nodes = ["empty"]
+        self.cnt = 0
+        self.abset = dict()
+        self._set = dict()
+        self.ans= []
+        self.cnt_abset = 0
+    def cfind(self,tag):
+        for i in range(1,self.cnt+1)[::-1]:
+            if self.nodes[i].has(tag):
+                return self.nodes[i]
+        self.cnt += 1
+        self.nodes.append(DAGNode(tag=tag))
+        return self.nodes[self.cnt]
+    def cfind_op1(self,op,lc,rc):
+        for i in range(1,self.cnt+1)[::-1]:
+            if self.nodes[i].op==op and ((self.nodes[i].lc == lc and self.nodes[i].rc == rc) or (self.nodes[i].lc == rc and self.nodes[i].rc == lc)):
+                return self.nodes[i]
+        self.cnt +=1
+        self.nodes.append(DAGNode(op=op,l=lc,r=rc))
+        return  self.nodes[self.cnt]
+    def cfind_op2(self,op,lc,rc):
+        for i in range(1, self.cnt + 1)[::-1]:
+            if self.nodes[i].op == op and self.nodes[i].lc == lc and self.nodes[i].rc == rc:
+                return self.nodes[i]
+        self.cnt += 1
+        self.nodes.append(DAGNode(op=op, l=lc, r=rc))
+        return self.nodes[self.cnt]
+    def cfindeq(self,tag):
+        for  i in range(1,self.cnt+1)[::-1]:
+            if self.nodes[i].has(tag):
+                return [1,self.nodes[i]]
+        self.cnt += 1
+        node = DAGNode()
+        self.nodes.append(node)
+        return [0,node]
 
-        if op == '=' and arg1.isdigit():
+    def build(self,lst):
-            # 常量赋值：如 (=, 32, _, _v0)
+        fg = False
-            value_map[dest] = arg1
+        for _ in lst:
-        elif op == '=':
+            if tp(_.d)==1 and self.abset.get(_.d) is None:
-            # 变量赋值：如 (=, _v0, _, age)
+                self.abset[_.d] = True
-            if arg1 in value_map:
+                self.cnt_abset += 1
-                new_quad = ('=', value_map[arg1], '_', dest)
+        self.ans = []
-                optimized.append(new_quad)
+        for _ in lst:
-                value_map[dest] = value_map[arg1]
+            op,a,b,res = _.a,_.b,_.c,_.d
-            else:
+            if op =='=':
-                optimized.append(quad)
+                # 将ans插入到a的节点中
-                # 如果 dest 不再被使用，可以考虑删除该赋值
+                num,node = self.cfindeq(a)
-        else:
+                if num == 0:
-            # 替换操作数中的变量为已知常量
+                    node.main_tag = a
-            new_arg1 = value_map.get(arg1, arg1)
+                    node.other_tag.add(res)
-            new_arg2 = value_map.get(arg2, arg2) if arg2 != '_' else '_'
+                    node.other_tag.add(a)
-            optimized.append((op, new_arg1, new_arg2, dest))
+                else:
+                    node.insert(res)
+                if node.op is None:
+                    node.op = '='
+            elif op =='+' or op=='*' or op =='==' or op == '!=':
+                # 首先找一下有没有a b节点 , 没有就自己造一个
+                aNode = self.cfind(a)
+                bNode = self.cfind(b)
+                if tp(aNode.main_tag) == tp(bNode.main_tag) and tp(aNode.main_tag) == 2:
+                    val = (f(op,aNode.main_tag,bNode.main_tag))
+                    if is_f(aNode.main_tag) or is_f(bNode.main_tag):
+                        val = str(val)
+                    else:
+                        val = str(int(val))
+                    self.cnt += 1
+                    Node = DAGNode(val)
+                    Node.insert(res)
+                    Node.op = '='
+                    self.nodes.append(Node)
+                    continue
+                # 然后找一下有没有a op b 的节点 , 有的话插进去
+                # 这里并不能根据a ,b 来查找 , 因为昔人已乘黄鹤去 ,  你找到的或许只是曾经的ab
 
-    return optimized
+                self.cfind_op1(op,aNode,bNode).insert(res)
+            elif op =='-' or op=='%' or op=='/':
+                # 这种不换的元素符
+                aNode = self.cfind(a)
+                bNode = self.cfind(b)
+                if tp(aNode.main_tag) == tp(bNode.main_tag) and tp(aNode.main_tag) == 2:
+                    val = (f(op,aNode.main_tag,bNode.main_tag))
+                    print(aNode.main_tag,bNode.main_tag)
+                    if is_f(aNode.main_tag) or is_f(bNode.main_tag):
+                        val = str(val)
+                    else:
+                        val = str(int(val))
+                    self.cnt += 1
+                    Node = DAGNode(val)
+                    Node.insert(res)
+                    Node.op = '='
+                    self.nodes.append(Node)
+                    continue
+                self.cfind_op2(op,self.cfind(a),self.cfind(b)).insert(res)
+            # 剩下就是while end , if end , el等 , 不用管
 
-# 第二步: 公共子表达式消除
+        for i in range(1,self.cnt+1)[::-1]:
-def common_subexpression_elimination(quads):
+            _ = self.nodes[i]
-    #print("Running Common Subexpression Elimination")
+            op = _.op
-    expr_map = {}
-    optimized = []
-    temp_counter = 0
 
-    for quad in quads:
+            if op is not None or len(_.other_tag)>1:
-        op, arg1, arg2, dest = quad
+                if _.lc is not None and _.rc is not None:
 
-        if op in ['+', '-', '*', '/']:
+                    if tp(_.main_tag) == 1:
-            expr_key = f"{arg1} {op} {arg2}"
+                        if self.abset[_.main_tag] == True:
-            if expr_key in expr_map:
+                            self.ans.append(FourTuple(op,_.lc.main_tag,_.rc.main_tag,_.main_tag))
-                # 复用已有结果
+                            self.abset[_.main_tag] = False
-                reused_var = expr_map[expr_key]
+                            self.cnt_abset -=1
-                optimized.append(('=', reused_var, '_', dest))
-            else:
-                # 新表达式
-                temp_var = f"_t{temp_counter}"
-                temp_counter += 1
-                expr_map[expr_key] = temp_var
-                optimized.append((op, arg1, arg2, temp_var))
-                optimized.append(('=', temp_var, '_', dest))
-        else:
-            optimized.append(quad)
 
-    return optimized
+                            if self.cnt_abset == 0:
-
+                                fg = True
-# 第三步: 死代码消除
+                                break
-def dead_code_elimination(quads):
+                    else:
-    #print("Running Dead Code Elimination")
+                        if self._set.get(_.main_tag) is None:
-    used_vars = set()
+                            self._set[_.main_tag] = 1
-    optimized = []
+                            self.ans.append(FourTuple(op, _.lc.main_tag, _.rc.main_tag, _.main_tag))
-
+                            self.abset[_.main_tag] = False
-    # 第一遍找出所有被使用的变量
+                if fg:
-    for quad in quads:
-        op, arg1, arg2, dest = quad
-        if arg1 != '_' and not arg1.isdigit():
-            used_vars.add(arg1)
-        if arg2 != '_' and not arg2.isdigit():
-            used_vars.add(arg2)
-
-    # 第二遍删除未使用变量的赋值语句
-    for quad in quads:
-        op, arg1, arg2, dest = quad
-        if op == '=' and dest.startswith('_v') and dest not in used_vars:
-            continue  # 跳过无用的赋值语句
-        optimized.append(quad)
-
-    return optimized
-
-
-
-# 第四步: 控制流优化
-def control_flow_simplification(quads):
-    # print("Running Control Flow Simplification")
-    optimized = []
-
-    for quad in quads:
-        op, arg1, arg2, dest = quad
-        if op == 'if' and arg2 == 'goto':
-            if arg1.isdigit():
-                if arg1 == '1':
-                    optimized.append(('goto', '_', '_', dest))
-                elif arg1 == '0':
-                    continue  # 恒假，跳过该条件跳转
-            else:
-                optimized.append(quad)
-        else:
-            optimized.append(quad)
-
-    return optimized
-
-# 第五步: 寄存器重用
-def register_reuse(quads):
-    #print("Running Register Reuse (Improved)")
-    
-    # 计算活跃变量信息
-    live_info = compute_live_vars(quads)
-    
-    optimized = []
-    available_temps = []  # 可用于复用的临时变量池
-
-    for i, quad in enumerate(quads):
-        op, arg1, arg2, dest = quad
-        current_live = live_info[i]
-
-        if op == '=':
-            # 查看当前 dest 是否会被后续使用
-            is_dest_used_later = dest in current_live
-
-            # 如果 dest 不再使用，可以加入可用池
-            if not is_dest_used_later and dest.startswith('_'):
-                available_temps.append(dest)
-
-            # 尝试复用已死的临时变量
-            reused = False
-            for var in list(available_temps):
-                if var not in [arg1, arg2] and var not in current_live:
-                    # 安全复用
-                    optimized.append(('=', arg1, arg2, var))
-                    available_temps.remove(var)
-                    if var != dest:
-                        available_temps.append(dest)  # 原 dest 现在可回收
-                    reused = True
                     break
+                for __ in _.other_tag:
+                    if __ != _.main_tag:
+                        if tp(__) == 1:
+                            if self.abset[__] == True:
 
-            if not reused:
+                                self.ans.append(FourTuple('=', _.main_tag, '_', __))
-                optimized.append(quad)
+                                self.abset[__] = False
-                if dest.startswith('_') and dest not in current_live:
+                                self.cnt_abset -= 1
-                    available_temps.append(dest)
-        else:
-            optimized.append(quad)
 
-    return optimized
+                                if self.cnt_abset == 0:
-
+                                    fg = True
-def compute_live_vars(quads):
+                                    break
-    """
+                        else:
-    活跃变量分析：从后往前推导每个 quad 之后仍会使用的变量
+                            if self._set.get(__) == None:
-    """
+                                self._set[__] = 1
-    live_vars = set()
+                                self.ans.append(FourTuple('=',_.main_tag,c='_',d=__))
-    live_info = []
+                if fg:
-
+                    break
-    for quad in reversed(quads):
+        self.ans = self.ans[::-1]
-        op, arg1, arg2, dest = quad
-
-        # 先移除 dest 的影响（因为 dest 被重新定义）
-        if dest in live_vars:
-            live_vars.remove(dest)
-
-        # 如果操作数是变量，则加入活跃集合
-        if arg1 != '_' and not arg1.isdigit():
-            live_vars.add(arg1)
-        if arg2 != '_' and not arg2.isdigit():
-            live_vars.add(arg2)
-
-        # 把当前活跃变量集合复制一份保存下来
-        live_info.append(live_vars.copy())
-
-    # 从后往前遍历，所以需要反转结果
-    live_info.reverse()
-    return live_info
 
 
-# 优化器整合
+if __name__ == '__main__':
-def optimize(quads):
+    divider = BlockDivider(l)
-    passes = [
+    optimizer = Optimizer()
-        ("Constant Propagation", constant_propagation),
+    ls = divider.run()
-        ("Common Subexpression Elimination", common_subexpression_elimination),
+    for l in ls:
-        ("Dead Code Elimination", dead_code_elimination),
+        optimizer.build(l)
-        ("Control Flow Simplification", control_flow_simplification),
+        for i in optimizer.ans:
-        ("Register Reuse", register_reuse),
+            print(i)
-    ]
 
-    for name, opt_func in passes:
-        # print(f"Running optimization pass: {name}")
-        quads = opt_func(quads)
-
-    return quads
-
-def output_ir_str(quads):
-    lines = []
-    for i, quad in enumerate(quads):
-        op, arg1, arg2, dest = quad
-        quad = f"({op}, {arg1}, {arg2}, {dest})"
-        lines.append(f"{i}  {quad}")
-    return "\n".join(lines)
 

Optimizer/block.py

@@ -0,0 +1,57 @@
+l = [
+    '=,1,_,t',
+
+    '=,5,_,t',
+    '=,2,_,_t2',
+    '=,4,_,_t1',
+    '+,4,_t2,_t3',
+    '-,_t2,_t3,_t1',
+]
+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()

main.py

@@ -5,7 +5,6 @@ from lexical.lexical import Lexical
 from syntax.syntax import Syntax
 from syntax.syntax import LL1Generator
 import sys
-from Optimizer.optimizer import optimize, output_ir_str
 
 from semantic.rule import symbol_table_pool
 
@@ -49,15 +48,6 @@ if lexical_success:
         for code in syntax.get_result().root.code:
             i += 1
             print(i, '  \t', code)
-
-        quads = [tuple(map(str.strip, str(item).strip("()").split(","))) for item in syntax.get_result().root.code]
-
-        optimized_quads = optimize(quads)
-
-        print()
-        print(f"优化后的四元式:\t")
-        print(output_ir_str(optimized_quads))
-
     else:
         print('错误原因:\t', syntax.get_error().info)
 else:

test0.hy

@@ -1,3 +0,0 @@
-fn main() {
-    
-}

test4.hy

@@ -1,7 +1,7 @@
 // test4：嵌套 if 判断（复杂控制流）
 
 fn max(x: i32, y: i32) -> i32 {
-    if x >= y {
+    if x > y {
         return x;
     } else {
         return y;

test8.hy

@@ -1,4 +0,0 @@
-fn main( :i32)
-{
-	a = 34 * 3;
-}

tk_ui.py

@@ -4,7 +4,6 @@ from lexical.lexical import Lexical
 from syntax.syntax import Syntax
 from semantic.rule import symbol_table_pool
 from syntax.syntax import LL1Generator
-from Optimizer.optimizer import optimize, output_ir_str
 
 def process_code(input_code):
     lexical = Lexical()
@@ -31,14 +30,6 @@ def process_code(input_code):
             for code in syntax.get_result().root.code:
                 i += 1
                 output.append(f"{i}  \t{code}")
-
-            quads = [tuple(map(str.strip, str(item).strip("()").split(","))) for item in syntax.get_result().root.code]
-
-            optimized_quads = optimize(quads)
-        
-            output.append('\n')
-            output.append(f"优化后的四元式:\t")
-            output.append(output_ir_str(optimized_quads))
             return '\n'.join(output), ''
         else:
             return '\n'.join(output), '错误原因:\t' + syntax.get_error().info
@@ -65,27 +56,12 @@ root.title("Hydrogen语言编译器前端演示")
 input_text = scrolledtext.ScrolledText(root, width=80, height=20)
 input_text.pack(padx=10, pady=5)
 
-# 提交按钮和清空按钮在同一行
+# 提交按钮
-button_frame = tk.Frame(root)
-def on_generate_ll1_table():
-    try:
-        obj = LL1Generator()
-        obj.compile()
-        obj.show_me_what_you_got("LL1_table.csv")
-        messagebox.showinfo("提示", "成功生成预测表")
-    except Exception as e:
-        messagebox.showerror("生成预测表异常", str(e))
-
-submit_btn = tk.Button(button_frame, text="生成产生式的预测表", command=on_generate_ll1_table)
-
-submit_btn.pack(side=tk.LEFT, padx=5)
-
-button_frame.pack(pady=5)
 submit_btn = tk.Button(root, text="提交", command=on_submit)
 submit_btn.pack(pady=5)
 
 # 输出框
-output_text = scrolledtext.ScrolledText(root, width=80, height=20, bg="#000000")
+output_text = scrolledtext.ScrolledText(root, width=80, height=20, bg="#ffffff")
 output_text.pack(padx=10, pady=5)
 
 # 错误信息框