Merge pull request #420 from boriel/feature/refactorize_code

Feature/refactorize code

Author: boriel

src/arch/zx48k/optimizer/asm.py

@@ -1,26 +1,30 @@
 import re
 
+from typing import Dict
+from typing import Tuple
+from typing import Optional
+from typing import List
+
 from .patterns import RE_OUTC, RE_INDIR16
 from .helpers import single_registers
 from src.libzxbasm import z80
 
 # Dict of patterns to normalized instructions. I.e. 'ld a, 5' -> 'LD A,N'
-Z80_PATTERN = {}
+Z80_PATTERN: Dict[re.Pattern, z80.Opcode] = {}
 
 
-class Asm(object):
+class Asm:
     """ Defines an asm instruction
     """
-    def __init__(self, asm):
-        assert isinstance(asm, str)
+    def __init__(self, asm: str):
         asm = asm.strip()
         assert asm, "Empty instruction '{}'".format(asm)
-        self.inst = Asm.inst(asm)
+        self.inst = Asm.instruction(asm)
         self.oper = Asm.opers(asm)
         self.asm = '{} {}'.format(self.inst, ' '.join(asm.split(' ', 1)[1:])).strip()
         self.cond = Asm.condition(asm)
         self.output = Asm.result(asm)
-        self._bytes = None
+        self._bytes: Optional[Tuple[str]] = None
         self._max_tstates = None
         self.is_label = self.inst[-1] == ':'
 
@@ -31,7 +35,7 @@ def _compute_bytes(self):
                 self._max_tstates = opcode_data.T
                 return
 
-        self._bytes = tuple()
+        self._bytes = bytearray()
         self._max_tstates = 0
 
     @property
@@ -58,19 +62,18 @@ def max_tstates(self):
         return self._max_tstates
 
     @staticmethod
-    def inst(asm):
+    def instruction(asm: str) -> str:
         tmp = asm.strip(' \t\n').split(' ', 1)[0]
         return tmp.lower() if tmp.upper() in z80.Z80INSTR else tmp
 
     @staticmethod
-    def opers(inst):
+    def opers(inst: str) -> List[str]:
         """ Returns operands of an ASM instruction.
         Even "indirect" operands, like SP if RET or CALL is used.
         """
-        i = inst.strip(' \t\n').split(' ', 1)
-        I = i[0].lower()  # Instruction
-        i = ''.join(i[1:])
-        op = [x.strip() for x in i.split(',')]
+        car, cdr = (inst.strip(' \t\n') + ' ').split(' ', 1)
+        I = car.lower()  # Instruction
+        op = [x.strip() for x in cdr.split(',')]
 
         if I in {'call', 'jp', 'jr'} and len(op) > 1:
             op = op[1:] + ['f']
@@ -111,7 +114,7 @@ def opers(inst):
             op += ['sp']
 
         elif I == 'out':
-            if len(op) and RE_OUTC.match(op[0]):
+            if op and RE_OUTC.match(op[0]):
                 op[0] = 'c'
             else:
                 op.pop(0)
@@ -122,8 +125,8 @@ def opers(inst):
             else:
                 op.pop(1)
 
-        for i in range(len(op)):
-            tmp = RE_INDIR16.match(op[i])
+        for i, o in enumerate(op):
+            tmp = RE_INDIR16.match(o)
             if tmp is not None:
                 op[i] = '(' + op[i].strip()[1:-1].strip().lower() + ')'  # '  (  dE )  ' => '(de)'
 
@@ -138,7 +141,7 @@ def condition(asm):
         condition flag (it always execute) whilst RET C does.
         DJNZ has condition flag NZ
         """
-        i = Asm.inst(asm)
+        i = Asm.instruction(asm)
 
         if i not in {'call', 'jp', 'jr', 'ret', 'djnz'}:
             return None  # This instruction always execute
@@ -162,7 +165,7 @@ def result(asm):
         """ Returns which 8-bit registers (and SP for INC SP, DEC SP, etc.) are used by an asm
         instruction to return a result.
         """
-        ins = Asm.inst(asm)
+        ins = Asm.instruction(asm)
         op = Asm.opers(asm)
 
         if ins in ('or', 'and') and op == ['a']:

src/libzxbasm/asm.py

@@ -2,15 +2,13 @@
 # -*- coding: utf-8 -*-
 # vim: ts=4:et:sw=4
 
-from src.libzxbasm.z80 import Opcode, Z80SET
+from src.libzxbasm.z80 import Z80SET
 from src.api.errors import Error
 import re
 
 # Reg. Exp. for counting N args in an asm mnemonic
 ARGre = re.compile(r'\bN+\b')
 
-Z80_re = {}  # Reg. Expr dictionary to cache them
-
 Z80_8REGS = ('A', 'B', 'C', 'D', 'E', 'H', 'L',
              'IXh', 'IYh', 'IXl', 'IYl', 'I', 'R')
 
@@ -20,17 +18,17 @@
               }
 
 
-def num2bytes(x, bytes):
+def num2bytes(x, bytes_):
     """ Returns x converted to a little-endian t-uple of bytes.
     E.g. num2bytes(255, 4) = (255, 0, 0, 0)
     """
     if not isinstance(x, int):  # If it is another "thing", just return ZEROs
-        return tuple([0] * bytes)
+        return tuple([0] * bytes_)
 
-    x = x & ((2 << (bytes * 8)) - 1)  # mask the initial value
+    x = x & ((2 << (bytes_ * 8)) - 1)  # mask the initial value
     result = ()
 
-    for i in range(bytes):
+    for i in range(bytes_):
         result += (x & 0xFF,)
         x >>= 8
 
@@ -70,10 +68,9 @@ def __init__(self, current_size, asm):
         self.asm = asm
 
 
-class AsmInstruction(Opcode):
+class AsmInstruction:
     """ Derives from Opcode. This one checks for opcode validity.
     """
-
     def __init__(self, asm, arg=None):
         """ Parses the given asm instruction and validates
         it against the Z80SET table. Raises InvalidMnemonicError
@@ -98,10 +95,11 @@ def __init__(self, asm, arg=None):
             self.comments = ''
 
         asm = asm[0]
-        if asm.upper() not in Z80SET.keys():
-            raise InvalidMnemonicError(asm)
 
         self.mnemo = asm.upper()
+        if self.mnemo not in Z80SET.keys():
+            raise InvalidMnemonicError(asm)
+
         Z80 = Z80SET[self.mnemo]
 
         self.asm = asm
@@ -125,7 +123,7 @@ def argval(self):
 
         return self.arg
 
-    def bytes(self):
+    def bytes(self) -> bytearray:
         """ Returns a t-uple with instruction bytes (integers)
         """
         result = []
@@ -147,7 +145,7 @@ def bytes(self):
         if len(result) != self.size:
             raise InternalMismatchSizeError(len(result), self)
 
-        return result
+        return bytearray(result)
 
     def __str__(self):
         return self.asm

src/libzxbasm/z80.py

@@ -2,15 +2,14 @@
 # -*- coding: utf-8 -*-
 # vim:ts=4:et:
 
+from typing import NamedTuple
 
-class Opcode:
-    """ Describes opcodes and other info.
-    """
-    def __init__(self, asm: str, time: int, size: int, opcode: str):
-        self.asm = asm
-        self.T = time
-        self.size = size
-        self.opcode = opcode
+
+class Opcode(NamedTuple):
+    asm: str
+    T: int
+    size: int
+    opcode: str
 
 
 Z80SET = {