#19 [tafka] transformed from imports to module imports

sleepy/asmik/emit.py

@@ -1,6 +1,6 @@
 from typing import override
 
-import sleepy.tafka.representation as tafka
+import sleepy.tafka.representation as taf
 from sleepy.tafka.walker import TafkaWalker
 
 from .argument import Immediate, Integer, Unassigned
@@ -32,7 +32,7 @@ def __init__(self) -> None:
         self.sequence = (VirtReg(n) for n in range(10000))
         self.binded: dict[str, Reg] = {}
 
-    def binded_to(self, var: tafka.Var) -> Reg:
+    def binded_to(self, var: taf.Var) -> Reg:
         var_repr = repr(var)
         if var_repr not in self.binded:
             self.binded[var_repr] = self.temporary()
@@ -50,48 +50,48 @@ def __init__(self) -> None:
         self.resolved: dict[str, int] = {}
 
     @override
-    def enter_procedure(self, procedure: tafka.Procedure) -> None:
+    def enter_procedure(self, procedure: taf.Procedure) -> None:
         addr = self.memory.data_put(IntegerData(self.next_instr_addr))
         self.resolved[repr(procedure.const)] = addr
         for i, param in enumerate(procedure.parameters):
             register = self.registers.binded_to(param)
             self.emit(mov(register, PhysReg.arg(i + 1)))
 
     @override
-    def exit_procedure(self, procedure: tafka.Procedure) -> None:
+    def exit_procedure(self, procedure: taf.Procedure) -> None:
         pass
 
     @override
-    def enter_block(self, block: tafka.Block) -> None:
+    def enter_block(self, block: taf.Block) -> None:
         self.resolved[repr(block.label)] = self.next_instr_addr
 
     @override
-    def exit_block(self, block: tafka.Block) -> None:
+    def exit_block(self, block: taf.Block) -> None:
         pass
 
     @override
-    def enter_statement(self, statement: tafka.Statement) -> None:
+    def enter_statement(self, statement: taf.Statement) -> None:
         pass
 
     @override
-    def exit_statement(self, statement: tafka.Statement) -> None:
+    def exit_statement(self, statement: taf.Statement) -> None:
         pass
 
     @override
-    def on_return(self, ret: tafka.Return) -> None:
+    def on_return(self, ret: taf.Return) -> None:
         retr = self.registers.binded_to(ret.value)
         self.emit(mov(Reg.a1(), retr))
         self.emit(Brn(Reg.ze(), Reg.ra()))
 
     @override
-    def on_goto(self, goto: tafka.Goto) -> None:
+    def on_goto(self, goto: taf.Goto) -> None:
         block_label = repr(goto.block.label)
         label = self.registers.temporary()
         self.emit(movi(label, Unassigned(block_label)))
         self.emit(Brn(Reg.ze(), label))
 
     @override
-    def on_conditional(self, conditional: tafka.Conditional) -> None:
+    def on_conditional(self, conditional: taf.Conditional) -> None:
         else_label = repr(conditional.else_branch.label)
         condition = self.registers.binded_to(conditional.condition)
         else_address = self.registers.temporary()
@@ -101,8 +101,8 @@ def on_conditional(self, conditional: tafka.Conditional) -> None:
     @override
     def on_invokation(
         self,
-        target: tafka.Var,
-        source: tafka.Invokation,
+        target: taf.Var,
+        source: taf.Invokation,
     ) -> None:
         for i, arg in enumerate(source.args):
             arg_reg = self.registers.binded_to(arg)
@@ -121,36 +121,36 @@ def on_invokation(
         self.emit(mov(Reg.ra(), prev_ra))
 
     @override
-    def on_load(self, target: tafka.Var, source: tafka.Load) -> None:
+    def on_load(self, target: taf.Var, source: taf.Load) -> None:
         dst = self.registers.binded_to(target)
         addr = self.addr_of(source.constant)
         self.emit(Addim(dst, Reg.ze(), addr))
         self.emit(Load(dst, dst))
 
     @override
-    def on_copy(self, target: tafka.Var, source: tafka.Copy) -> None:
+    def on_copy(self, target: taf.Var, source: taf.Copy) -> None:
         dst = self.registers.binded_to(target)
         src = self.registers.binded_to(source.argument)
         self.emit(mov(dst, src))
 
     @override
-    def on_sum(self, target: tafka.Var, source: tafka.Sum) -> None:
+    def on_sum(self, target: taf.Var, source: taf.Sum) -> None:
         self.on_trivial_binary_operation(target, source)
 
     @override
-    def on_mul(self, target: tafka.Var, source: tafka.Mul) -> None:
+    def on_mul(self, target: taf.Var, source: taf.Mul) -> None:
         self.on_trivial_binary_operation(target, source)
 
     @override
-    def on_div(self, target: tafka.Var, source: tafka.Div) -> None:
+    def on_div(self, target: taf.Var, source: taf.Div) -> None:
         self.on_trivial_binary_operation(target, source)
 
     @override
-    def on_rem(self, target: tafka.Var, source: tafka.Rem) -> None:
+    def on_rem(self, target: taf.Var, source: taf.Rem) -> None:
         self.on_trivial_binary_operation(target, source)
 
     @override
-    def on_eq(self, target: tafka.Var, source: tafka.Eq) -> None:
+    def on_eq(self, target: taf.Var, source: taf.Eq) -> None:
         dstr = self.registers.binded_to(target)
         lhsr = self.registers.binded_to(source.left)
         rhsr = self.registers.binded_to(source.right)
@@ -166,55 +166,55 @@ def on_eq(self, target: tafka.Var, source: tafka.Eq) -> None:
         self.emit(Xorb(dstr, orb, neg))
 
     @override
-    def on_lt(self, target: tafka.Var, source: tafka.Lt) -> None:
+    def on_lt(self, target: taf.Var, source: taf.Lt) -> None:
         self.on_trivial_binary_operation(target, source)
 
     @override
-    def on_and(self, target: tafka.Var, source: tafka.And) -> None:
+    def on_and(self, target: taf.Var, source: taf.And) -> None:
         self.on_trivial_binary_operation(target, source)
 
     @override
-    def on_or(self, target: tafka.Var, source: tafka.Or) -> None:
+    def on_or(self, target: taf.Var, source: taf.Or) -> None:
         self.on_trivial_binary_operation(target, source)
 
     def on_trivial_binary_operation(
         self,
-        target: tafka.Var,
-        source: tafka.BinaryOperator,
+        target: taf.Var,
+        source: taf.BinaryOperator,
     ) -> None:
         dstr = self.registers.binded_to(target)
         lhsr = self.registers.binded_to(source.left)
         rhsr = self.registers.binded_to(source.right)
 
         instruction: Instruction
         match source:
-            case tafka.Sum():
+            case taf.Sum():
                 instruction = Addi(dstr, lhsr, rhsr)
-            case tafka.Mul():
+            case taf.Mul():
                 instruction = Muli(dstr, lhsr, rhsr)
-            case tafka.Div():
+            case taf.Div():
                 instruction = Divi(dstr, lhsr, rhsr)
-            case tafka.Rem():
+            case taf.Rem():
                 instruction = Remi(dstr, lhsr, rhsr)
-            case tafka.Lt():
+            case taf.Lt():
                 instruction = Slti(dstr, lhsr, rhsr)
-            case tafka.And():
+            case taf.And():
                 instruction = Andb(dstr, lhsr, rhsr)
-            case tafka.Or():
+            case taf.Or():
                 instruction = Orb(dstr, lhsr, rhsr)
 
         self.emit(instruction)
 
     def emit(self, instr: Instruction) -> None:
         self.memory.instr.append(instr)
 
-    def addr_of(self, cnst: tafka.Const) -> Immediate:
+    def addr_of(self, cnst: taf.Const) -> Immediate:
         match cnst.kind:
-            case tafka.Int():
+            case taf.Int():
                 data = IntegerData(int(cnst.name))
                 addr = self.memory.data_put(data)
                 return Integer(addr)
-            case tafka.Signature():
+            case taf.Signature():
                 return Unassigned(repr(cnst))
             case _:
                 raise NotImplementedError