Add ZX Next ASM capabilities for ZXBasm

Author: boriel

api/config.py

@@ -68,6 +68,7 @@ def init():
     OPTIONS.add_option('explicit', bool, False)
     OPTIONS.add_option('Sinclair', bool, False)
     OPTIONS.add_option('strict', bool, False)  # True to force type checking
+    OPTIONS.add_option('zxnext', bool, False)  # True to enable ZX Next ASM opcodes
 
 
 init()

asmlex.py

@@ -93,6 +93,31 @@
     'xor': 'XOR',
 }
 
+zx_next_mnemonics = {
+    x.lower(): x for x in [
+        "LDIX",
+        "LDWS",
+        "LDIRX",
+        "LDDX",
+        "LDDRX",
+        "LDPIRX",
+        "OUTINB",
+        "MUL",
+        "SWAPNIB",
+        "MIRROR",
+        "NEXTREG",
+        "PIXELDN",
+        "PIXELAD",
+        "SETAE",
+        "TEST",
+        "BSLA",
+        "BSRA",
+        "BSRL",
+        "BSRF",
+        "BRLC"
+    ]
+}
+
 pseudo = {  # pseudo ops
     'align': 'ALIGN',
     'org': 'ORG',
@@ -154,6 +179,7 @@
     tuple(regs8.values()) +
     tuple(regs16.values()) +
     tuple(flags.values()) +
+    tuple(zx_next_mnemonics.values()) +
     tuple(preprocessor.values())
 )
 
@@ -162,7 +188,8 @@
     regs16.keys()).union(
     regs8.keys()).union(
     pseudo.keys()).union(
-    reserved_instructions.keys())
+    reserved_instructions.keys()).union(
+    zx_next_mnemonics.keys())
 
 
 def get_uniques(l):
@@ -273,6 +300,11 @@ def t_INITIAL_ID(self, t):
         if t.type is not None:
             return t
 
+        if OPTIONS.zxnext.value:
+            t.type = zx_next_mnemonics.get(id_)
+            if t.type is not None:
+                return t
+
         t.type = regs16.get(id_, 'ID')
         if t.type == 'ID':
             t.value = tmp  # Restores original value

asmparse.py

@@ -1455,7 +1455,12 @@ def assemble(input_):
     if MEMORY is None:
         MEMORY = Memory()
 
-    parser.parse(input_, lexer=LEXER, debug=OPTIONS.Debug.value > 2)
+    if OPTIONS.zxnext.value:
+        parser_ = zxnext_parser
+    else:
+        parser_ = parser
+
+    parser_.parse(input_, lexer=LEXER, debug=OPTIONS.Debug.value > 2)
     if len(MEMORY.scopes):
         error(MEMORY.scopes[-1], 'Missing ENDP to close this scope')
 
@@ -1541,4 +1546,13 @@ def main(argv):
     generate_binary(OPTIONS.outputFileName.value, OPTIONS.output_file_type)
 
 
-parser = api.utils.get_or_create('asmparse', lambda: yacc.yacc(debug=OPTIONS.Debug.value > 2))
+# Z80 only ASM parser
+parser = api.utils.get_or_create('asmparse',
+                                 lambda: yacc.yacc(start="start", debug=OPTIONS.Debug.value > 2))
+
+# needed for ply
+from zxnext import *  # noqa
+
+# ZXNEXT extended OPcodes parser
+zxnext_parser = api.utils.get_or_create('zxnext_asmparse',
+                                        lambda: yacc.yacc(start="start", debug=OPTIONS.Debug.value > 2))

parsetab/tabs.dbm.bak

@@ -1,3 +1,4 @@
 'zxbppparse', (0, 68810)
-'zxbparser', (69120, 707013)
-'asmparse', (776192, 250068)
+'asmparse', (69120, 250081)
+'zxnext_asmparse', (319488, 280962)
+'zxbparser', (600576, 707013)

parsetab/tabs.dbm.dat

@@ -1,3 +1,4 @@
 'zxbppparse', (0, 68810)
-'zxbparser', (69120, 707013)
-'asmparse', (776192, 250068)
+'asmparse', (69120, 250081)
+'zxnext_asmparse', (319488, 280962)
+'zxbparser', (600576, 707013)

parsetab/tabs.dbm.dir

@@ -16,7 +16,6 @@
 import argparse
 
 import asmparse
-from asmparse import Asm, Expr, Container
 import zxbpp
 
 import api.config
@@ -66,6 +65,9 @@ def main(args=None):
     o_parser.add_argument("-b", "--bracket", action="store_true", default=False,
                           help="Allows brackets only for memory access and indirections")
 
+    o_parser.add_argument('-N', "--zxnext", action="store_true", default=False,
+                          help="Enable ZX Next extra ASM opcodes!")
+
     o_parser.add_argument("--version", action="version", version="%(prog)s " + VERSION)
 
     options = o_parser.parse_args(args)
@@ -83,6 +85,7 @@ def main(args=None):
     OPTIONS.StdErrFileName.value = options.stderr
     OPTIONS.memory_map.value = options.memory_map
     OPTIONS.bracket.value = options.bracket
+    OPTIONS.zxnext.value = options.zxnext
 
     if options.tzx:
         OPTIONS.output_file_type.value = 'tzx'
@@ -123,15 +126,15 @@ def main(args=None):
     current_org = max(asmparse.MEMORY.memory_bytes.keys() or [0]) + 1
 
     for label, line in asmparse.INITS:
-        expr_label = Expr.makenode(Container(asmparse.MEMORY.get_label(label, line), line))
-        asmparse.MEMORY.add_instruction(Asm(0, 'CALL NN', expr_label))
+        expr_label = asmparse.Expr.makenode(asmparse.Container(asmparse.MEMORY.get_label(label, line), line))
+        asmparse.MEMORY.add_instruction(asmparse.Asm(0, 'CALL NN', expr_label))
 
     if len(asmparse.INITS) > 0:
         if asmparse.AUTORUN_ADDR is not None:
-            asmparse.MEMORY.add_instruction(Asm(0, 'JP NN', asmparse.AUTORUN_ADDR))
+            asmparse.MEMORY.add_instruction(asmparse.Asm(0, 'JP NN', asmparse.AUTORUN_ADDR))
         else:
             asmparse.MEMORY.add_instruction(
-                Asm(0, 'JP NN', min(asmparse.MEMORY.orgs.keys())))  # To the beginning of binary. Ehem...
+                asmparse.Asm(0, 'JP NN', min(asmparse.MEMORY.orgs.keys())))  # To the beginning of binary
 
         asmparse.AUTORUN_ADDR = current_org
 

zxbasm.py

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+
+__all__ = [
+    'p_mul_d_e',
+    'p_simple_instruction',
+    'p_add_reg16_a',
+    'p_JP_c',
+    'p_bxxxx_de_b',
+    'p_add_reg_NN',
+    'p_test_nn',
+    'p_nextreg_expr',
+    'p_nextreg_a',
+    'p_push_imm'
+]
+
+
+import asmparse
+
+
+def p_mul_d_e(p):
+    """ asm : MUL D COMMA E
+    """
+    p[0] = asmparse.Asm(p.lineno(1), 'MUL D,E')
+
+
+def p_simple_instruction(p):
+    """ asm : LDIX
+            | LDWS
+            | LDIRX
+            | LDDX
+            | LDDRX
+            | LDPIRX
+            | OUTINB
+            | SWAPNIB
+            | MIRROR
+            | PIXELDN
+            | PIXELAD
+            | SETAE
+    """
+    p[0] = asmparse.Asm(p.lineno(1), p[1])
+
+
+def p_add_reg16_a(p):
+    """ asm : ADD HL COMMA A
+            | ADD DE COMMA A
+            | ADD BC COMMA A
+    """
+    p[0] = asmparse.Asm(p.lineno(1), 'ADD {},A'.format(p[2]))
+
+
+def p_JP_c(p):
+    """ asm : JP LP C RP
+    """
+    p[0] = asmparse.Asm(p.lineno(1), 'JP (C)')
+
+
+def p_bxxxx_de_b(p):
+    """ asm : BSLA DE COMMA B
+            | BSRA DE COMMA B
+            | BSRL DE COMMA B
+            | BSRF DE COMMA B
+            | BRLC DE COMMA B
+    """
+    p[0] = asmparse.Asm(p.lineno(1), '{} DE,B'.format(p[1]))
+
+
+def p_add_reg_NN(p):
+    """ asm : ADD HL COMMA expr
+            | ADD DE COMMA expr
+            | ADD BC COMMA expr
+            | ADD HL COMMA pexpr
+            | ADD DE COMMA pexpr
+            | ADD BC COMMA pexpr
+    """
+    p[0] = asmparse.Asm(p.lineno(1), 'ADD {},NN'.format(p[2]), p[4])
+
+
+def p_test_nn(p):
+    """ asm : TEST expr
+            | TEST pexpr
+    """
+    p[0] = asmparse.Asm(p.lineno(1), 'TEST N', p[2])
+
+
+def p_nextreg_expr(p):
+    """ asm : NEXTREG expr COMMA expr
+            | NEXTREG expr COMMA pexpr
+            | NEXTREG pexpr COMMA expr
+            | NEXTREG pexpr COMMA pexpr
+    """
+    p[0] = asmparse.Asm(p.lineno(1), 'NEXTREG N,N', (p[2], p[4]))
+
+
+def p_nextreg_a(p):
+    """ asm : NEXTREG expr COMMA A
+            | NEXTREG pexpr COMMA A
+    """
+    p[0] = asmparse.Asm(p.lineno(1), 'NEXTREG N,A', p[2])
+
+
+def p_push_imm(p):
+    """ asm : PUSH expr
+            | PUSH pexpr
+    """
+    # Reverse HI | LO => X1 = (X0 & 0xFF) << 8 | (X0 >> 8) & 0xFF
+    mknod = asmparse.Expr.makenode
+    cont = lambda x: asmparse.Container(x, p.lineno(1))
+    ff = mknod(cont(0xFF))
+    n8 = mknod(cont(8))
+
+    expr = mknod(
+        cont('|'),
+        mknod(cont('<<'), mknod(cont('&'), p[2], ff), n8),
+        mknod(cont('&'), mknod(cont('>>'), p[2], n8), ff)
+    )
+    p[0] = asmparse.Asm(p.lineno(1), 'PUSH NN', expr)