Merged in feature/append_binary (pull request #188)

Feature/append binary

Approved-by: Jose Rodriguez <boriel@gmail.com>

Author: boriel

arch/zx48k/backend/__init__.py

@@ -2164,11 +2164,11 @@ def __str__(self):
 # -------------------------
 def emit_start():
     output = list()
+    output.append('org %s' % OPTIONS.org.value)
+
     if OPTIONS.headerless.value:
         return output
 
-    output.append('org %s' % OPTIONS.org.value)
-
     if REQUIRES.intersection(MEMINITS) or '__MEM_INIT' in INITS:
         output.append('; Defines HEAP SIZE\n' + OPTIONS.heap_size_label.value + ' EQU ' + str(OPTIONS.heap_size.value))
 

asmparse.py

@@ -26,6 +26,7 @@
 from api import global_ as gl
 import api.utils
 import zxbpp
+import outfmt
 
 LEXER = asmlex.Lexer()
 
@@ -1438,7 +1439,7 @@ def assemble(input_):
     return gl.has_errors
 
 
-def generate_binary(outputfname, format_, progname=''):
+def generate_binary(outputfname, format_, progname='', binary_files=None, headless_binary_files=None):
     """ Outputs the memory binary to the
     output filename using one of the given
     formats: tap, tzx or bin
@@ -1449,6 +1450,22 @@ def generate_binary(outputfname, format_, progname=''):
     if gl.has_errors:
         return
 
+    if binary_files is None:
+        binary_files = []
+
+    if headless_binary_files is None:
+        headless_binary_files = []
+
+    bin_blocks = []
+    for fname in binary_files:
+        with api.utils.open_file(fname) as f:
+            bin_blocks.append((os.path.basename(fname), f.read()))
+
+    headless_bin_blocks = []
+    for fname in headless_binary_files:
+        with api.utils.open_file(fname) as f:
+            headless_bin_blocks.append(f.read())
+
     if AUTORUN_ADDR is None:
         AUTORUN_ADDR = org
 
@@ -1468,24 +1485,18 @@ def generate_binary(outputfname, format_, progname=''):
         else:
             program.add_line([['REM'], ['RANDOMIZE', program.token('USR'), AUTORUN_ADDR]])
 
-    if format_ == 'tzx':
-        import outfmt
-        t = outfmt.TZX()
+    if format_ in ('tap', 'tzx'):
+        t = {'tap': outfmt.TAP, 'tzx': outfmt.TZX}[format_]()
 
         if OPTIONS.use_loader.value:
             t.save_program('loader', program.bytes, line=1)  # Put line 0 to protect against MERGE
 
         t.save_code(progname, org, binary)
-        t.dump(outputfname)
+        for name, block in bin_blocks:
+            t.save_code(name, 0, block)
+        for block in headless_bin_blocks:
+            t.standard_block(block)
 
-    elif format_ == 'tap':
-        import outfmt
-        t = outfmt.TAP()
-
-        if OPTIONS.use_loader.value:
-            t.save_program('loader', program.bytes, line=1)  # Put line 0 to protect against MERGE
-
-        t.save_code(progname, org, binary)
         t.dump(outputfname)
 
     else:

identityset.py

@@ -1,55 +1,55 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# vim:ts=4:et:
-
-import collections
-
-
-class IdentitySet(object):
-    """ This set implementation only adds items
-    if they are not exactly the same (same reference)
-    preserving its order (OrderedDict). Allows deleting by ith-index.
-    """
-    def __init__(self, l=None):
-        self.elems = []
-        self._elems = set()
-        if l is not None:
-            self.add(l)
-
-    def add(self, l):
-        if not isinstance(l, collections.Iterable):
-            l = [l]
-        self.elems.extend(x for x in l if x not in self._elems)
-        self._elems.update(x for x in l)
-
-    def remove(self, l):
-        if not isinstance(l, collections.Iterable):
-            l = [l]
-
-        self._elems.difference_update(l)
-        self.elems = [x for x in self.elems if x not in self._elems]
-
-    def __len__(self):
-        return len(self.elems)
-
-    def __getitem__(self, key):
-        return self.elems[key]
-
-    def __str__(self):
-        return str(self.elems)
-
-    def __contains__(self, elem):
-        return elem in self._elems
-
-    def __delitem__(self, key):
-        self.pop(self.elems.index(key))
-
-    def intersection(self, other):
-        return IdentitySet([x for x in self.elems if x in self._elems.intersection(other)])
-
-    def union(self, other):
-        return IdentitySet(self.elems + [x for x in other])
-
-    def pop(self, i):
-        tmp = self.elems.pop(i)
-        self._elems.remove(tmp)
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# vim:ts=4:et:
+
+import collections
+
+
+class IdentitySet(object):
+    """ This set implementation only adds items
+    if they are not exactly the same (same reference)
+    preserving its order (OrderedDict). Allows deleting by ith-index.
+    """
+    def __init__(self, l=None):
+        self.elems = []
+        self._elems = set()
+        if l is not None:
+            self.add(l)
+
+    def add(self, l):
+        if not isinstance(l, collections.Iterable):
+            l = [l]
+        self.elems.extend(x for x in l if x not in self._elems)
+        self._elems.update(x for x in l)
+
+    def remove(self, l):
+        if not isinstance(l, collections.Iterable):
+            l = [l]
+
+        self._elems.difference_update(l)
+        self.elems = [x for x in self.elems if x not in self._elems]
+
+    def __len__(self):
+        return len(self.elems)
+
+    def __getitem__(self, key):
+        return self.elems[key]
+
+    def __str__(self):
+        return str(self.elems)
+
+    def __contains__(self, elem):
+        return elem in self._elems
+
+    def __delitem__(self, key):
+        self.pop(self.elems.index(key))
+
+    def intersection(self, other):
+        return IdentitySet([x for x in self.elems if x in self._elems.intersection(other)])
+
+    def union(self, other):
+        return IdentitySet(self.elems + [x for x in other])
+
+    def pop(self, i):
+        tmp = self.elems.pop(i)
+        self._elems.remove(tmp)

tests/functional/headerless.asm

@@ -1,3 +1,4 @@
+	org 32768
 	ld hl, _a
 	inc (hl)
 	ld hl, 0

zxb.py

@@ -145,7 +145,11 @@ def main(args=None):
                         help='Header-less mode: omit asm prologue and epilogue')
     parser.add_argument('--version', action='version', version='%(prog)s {0}'.format(VERSION))
     parser.add_argument('--parse-only', action='store_true',
-                        help="Only parses to check for syntax and semantic errors")
+                        help='Only parses to check for syntax and semantic errors')
+    parser.add_argument('--append-binary', default=[], action='append',
+                        help='Appends binary to tape file (only works with -t or -T)')
+    parser.add_argument('--append-headless-binary', default=[], action='append',
+                        help='Appends binary to tape file (only works with -t or -T)')
 
     options = parser.parse_args(args=args)
 
@@ -201,6 +205,10 @@ def main(args=None):
         parser.error('Option --BASIC and --autorun requires --tzx or tap format')
         return 4
 
+    if options.append_binary and not options.tzx and not options.tap:
+        parser.error('Option --append-binary needs either --tap or --tzx')
+        return 5
+
     OPTIONS.use_loader.value = options.basic
     OPTIONS.autorun.value = options.autorun
 
@@ -330,7 +338,9 @@ def main(args=None):
         output(asm_output, fout)
         asmparse.assemble(fout.getvalue())
         fout.close()
-        asmparse.generate_binary(OPTIONS.outputFileName.value, OPTIONS.output_file_type.value)
+        asmparse.generate_binary(OPTIONS.outputFileName.value, OPTIONS.output_file_type.value,
+                                 binary_files=options.append_binary,
+                                 headless_binary_files=options.append_headless_binary)
         if gl.has_errors:
             return 5  # Error in assembly