Merge pull request #558 from boriel/feature/asm_temporary_labels

Feature/asm temporary labels

Author: boriel

src/arch/zx48k/library-asm/copy_attr.asm

@@ -67,7 +67,7 @@ TABLE:
 
 __REFRESH_TMP:
     ld a, (hl)
-    and 10101010b
+    and 0b10101010
     ld c, a
     rra
     or c

src/arch/zxnext/library-asm/copy_attr.asm

@@ -67,7 +67,7 @@ TABLE:
 
 __REFRESH_TMP:
     ld a, (hl)
-    and 10101010b
+    and 0b10101010
     ld c, a
     rra
     or c

src/outfmt/codeemitter.py

@@ -11,8 +11,22 @@
 # The code emission interface.
 # --------------------------------------------
 
+from abc import ABC, abstractmethod
 
-class CodeEmitter(object):
+
+class CodeEmitter(ABC):
     """ The base code emission interface.
     """
-    pass
+
+    @abstractmethod
+    def emit(
+            self,
+            output_filename: str,
+            program_name: str,
+            loader_bytes: bytearray,
+            entry_point,
+            program_bytes,
+            aux_bin_blocks,
+            aux_headless_bin_blocks
+    ):
+        pass

src/parsetab/tabs.dbm.bak

@@ -1,4 +1,4 @@
 'zxbpp', (0, 76970)
-'asmparse', (77312, 271961)
-'zxnext_asmparse', (349696, 302573)
-'zxbparser', (652288, 703160)
+'asmparse', (77312, 272467)
+'zxnext_asmparse', (350208, 303081)
+'zxbparser', (653312, 703160)

src/parsetab/tabs.dbm.dat

@@ -1,4 +1,4 @@
 'zxbpp', (0, 76970)
-'asmparse', (77312, 271961)
-'zxnext_asmparse', (349696, 302573)
-'zxbparser', (652288, 703160)
+'asmparse', (77312, 272467)
+'zxnext_asmparse', (350208, 303081)
+'zxbparser', (653312, 703160)

src/parsetab/tabs.dbm.dir

@@ -1,151 +1,120 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# vim: ts=4:et:sw=4
+from typing import Any, NamedTuple
 
-from src.zxbasm.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_8REGS = ('A', 'B', 'C', 'D', 'E', 'H', 'L',
-             'IXh', 'IYh', 'IXl', 'IYl', 'I', 'R')
-
-Z80_16REGS = {'AF': ('A', 'F'), 'BC': ('B', 'C'), 'DE': ('D', 'E'),
-              'HL': ('H', 'L'), 'SP': (),
-              'IX': ('IXh', 'IXl'), 'IY': ('IYh', 'IYl')
-              }
-
-
-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_)
+from src.api import errmsg
+from src.api import global_ as gl
 
-    x = x & ((2 << (bytes_ * 8)) - 1)  # mask the initial value
-    result = ()
-
-    for i in range(bytes_):
-        result += (x & 0xFF,)
-        x >>= 8
-
-    return result
+from src.api.errors import Error
+from src.zxbasm.expr import Expr
+from src.zxbasm.asm_instruction import AsmInstruction
 
 
-class InvalidMnemonicError(Error):
-    """ Exception raised when an invalid Mnemonic has been emitted.
+class Container(NamedTuple):
+    """ Single class container
     """
+    item: Any
+    lineno: int
 
-    def __init__(self, mnemo):
-        self.msg = "Invalid mnemonic '%s'" % mnemo
-        self.mnemo = mnemo
 
+class Asm(AsmInstruction):
+    """ Class extension to AsmInstruction with a short name :-P
+    and will trap some exceptions and convert them to error msgs.
 
-class InvalidArgError(Error):
-    """ Exception raised when an invalid argument has been emitted.
+    It will also record source line
     """
 
-    def __init__(self, arg):
-        self.msg = "Invalid argument '%s'. It must be an integer." % str(arg)
-        self.mnemo = arg
+    def __init__(self, lineno, asm, arg=None):
+        self.lineno = lineno
 
+        if asm not in ('DEFB', 'DEFS', 'DEFW'):
+            try:
+                super().__init__(asm, arg)
+            except Error as v:
+                errmsg.error(lineno, v.msg)
+                return
 
-class InternalMismatchSizeError(Error):
-    """ Exception raised when an invalid instruction length has been emitted.
-    """
-
-    def __init__(self, current_size, asm):
-        a = '' if current_size == 1 else 's'
-        b = '' if asm.size == 1 else 's'
+            self.pending = len([x for x in self.arg if isinstance(x, Expr) and x.try_eval() is None]) > 0
 
-        self.msg = ("Invalid instruction [%s] size (%i byte%s). "
-                    "It should be %i byte%s." % (asm.asm, current_size, a,
-                                                 asm.size, b))
-        self.current_size = current_size
-        self.asm = asm
+            if not self.pending:
+                self.arg = self.argval()
+        else:
+            self.asm = asm
+            self.pending = True
 
+            if isinstance(arg, str):
+                self.arg = tuple([Expr(Container(ord(x), lineno)) for x in arg])
+            else:
+                self.arg = arg
 
-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
-        if not valid.
+            self.arg_num = len(self.arg)
 
-        It uses the Z80SET global dictionary. Args is an optional
-        argument (it can be a Label object or a value)
+    def bytes(self) -> bytearray:
+        """ Returns opcodes
         """
-        if isinstance(arg, list):
-            arg = tuple(arg)
+        if self.asm not in ('DEFB', 'DEFS', 'DEFW'):
+            if self.pending:
+                tmp = self.arg  # Saves current arg temporarily
+                self.arg = (0, ) * self.arg_num
+                result = super(Asm, self).bytes()
+                self.arg = tmp  # And recovers it
 
-        if arg is None:
-            arg = ()
+                return result
 
-        if arg is not None and not isinstance(arg, tuple):
-            arg = (arg,)
+            return super(Asm, self).bytes()
 
-        asm = asm.split(';', 1)  # Try to get comments out, if any
-        if len(asm) > 1:
-            self.comments = ';' + asm[1]
-        else:
-            self.comments = ''
+        if self.asm == 'DEFB':
+            if self.pending:
+                return bytearray((0, ) * self.arg_num)
 
-        asm = asm[0]
+            return bytearray(x & 0xFF for x in self.argval())
 
-        self.mnemo = asm.upper()
-        if self.mnemo not in Z80SET.keys():
-            raise InvalidMnemonicError(asm)
+        if self.asm == 'DEFS':
+            if self.pending:
+                N = self.arg[0]
+                if isinstance(N, Expr):
+                    N = N.eval()
+                return (0, ) * N
 
-        Z80 = Z80SET[self.mnemo]
+            args = self.argval()
+            arg0 = args[0]
+            arg1 = args[1]
+            assert isinstance(arg0, int)
+            assert isinstance(arg1, int)
 
-        self.asm = asm
-        self.size = Z80.size
-        self.T = Z80.T
-        self.opcode = Z80.opcode
-        self.argbytes = tuple([len(x) for x in ARGre.findall(asm)])
-        self.arg = arg
-        self.arg_num = len(ARGre.findall(asm))
+            if arg1 > 255:
+                errmsg.warning_value_will_be_truncated(self.lineno)
+            num = arg1 & 0xFF
+            return bytearray((num, ) * arg0)
 
-    def argval(self):
-        """ Returns the value of the arg (if any) or None.
-        If the arg. is not an integer, an error be triggered.
-        """
-        if self.arg is None or any(x is None for x in self.arg):
-            return None
+        if self.pending:  # DEFW
+            return bytearray((0, ) * 2 * self.arg_num)
 
-        for x in self.arg:
-            if not isinstance(x, int):
-                raise InvalidArgError(self.arg)
+        result = bytearray()
+        for i in self.argval():
+            x = i & 0xFFFF
+            result.extend([x & 0xFF, x >> 8])
 
-        return self.arg
+        return bytearray(result)
 
-    def bytes(self) -> bytearray:
-        """ Returns a t-uple with instruction bytes (integers)
+    def argval(self):
+        """ Solve args values or raise errors if not
+        defined yet
         """
-        result = []
-        op = self.opcode.split(' ')
-        argi = 0
-
-        while op:
-            q = op.pop(0)
+        if gl.has_errors:
+            return [None]
 
-            if q == 'XX':
-                for k in range(self.argbytes[argi] - 1):
-                    op.pop(0)
+        if self.asm in ('DEFB', 'DEFS', 'DEFW'):
+            result = tuple([x.eval() if isinstance(x, Expr) else x for x in self.arg])
+            if self.asm == 'DEFB' and any(x > 255 for x in result):
+                errmsg.warning_value_will_be_truncated(self.lineno)
+            return result
 
-                result.extend(num2bytes(self.argval()[argi], self.argbytes[argi]))
-                argi += 1
-            else:
-                result.append(int(q, 16))  # Add opcode
-
-        if len(result) != self.size:
-            raise InternalMismatchSizeError(len(result), self)
+        self.arg = tuple([x if not isinstance(x, Expr) else x.eval() for x in self.arg])
+        if gl.has_errors:
+            return [None]
 
-        return bytearray(result)
+        if self.asm.split(' ')[0] in ('JR', 'DJNZ'):  # A relative jump?
+            if self.arg[0] < -128 or self.arg[0] > 127:
+                errmsg.error(self.lineno, 'Relative jump out of range')
+                return [None]
 
-    def __str__(self):
-        return self.asm
+        return super(Asm, self).argval()