Implements LBOUND / UBOUND in Local arrays

Author: boriel

arch/zx48k/backend/__init__.py

@@ -584,16 +584,29 @@ def _larrd(ins):
       - 1st param is offset of the local variable.
       - 2nd param is a list of bytes in hexadecimal corresponding to the index table
       - 3rd param is the size of elements in byte
-      - 4rd param a list (might be empty) of byte to initialize the array with
+      - 4th param is a list (might be empty) of byte to initialize the array with
+      - 5th param is a list (might be empty or 2 elements) of [lbound, ubound] labels.
     """
     output = []
 
     label = tmp_label()
     offset = int(ins.quad[1])
     elements_size = ins.quad[3]
     AT_END.extend(_vard(Quad('vard', label, ins.quad[2])))
-    must_initialize = ins.quad[4] != '[]'
 
+    bounds = eval(ins.quad[5])
+    if not isinstance(bounds, list) or len(bounds) not in (0, 2):
+        raise InvalidIC(ins.quad, 'Bounds list length must be 0 or 2, not %s' % ins.quad[5])
+
+    if bounds:
+        output.extend([
+            'ld hl, %s' % bounds[1],
+            'push hl',
+            'ld hl, %s' % bounds[0],
+            'push hl',
+        ])
+
+    must_initialize = ins.quad[4] != '[]'
     if must_initialize:
         label2 = tmp_label()
         AT_END.extend(_vard(Quad('vard', label2, ins.quad[4])))
@@ -608,10 +621,11 @@ def _larrd(ins):
         'ld bc, %s' % elements_size,
     ])
 
+    suffix = '_WITH_BOUNDS' if bounds else ''
     if must_initialize:
-        output.append('call __ALLOC_INITIALIZED_LOCAL_ARRAY')
+        output.append('call __ALLOC_INITIALIZED_LOCAL_ARRAY' + suffix)
     else:
-        output.append('call __ALLOC_LOCAL_ARRAY')
+        output.append('call __ALLOC_LOCAL_ARRAY' + suffix)
 
     REQUIRES.add('arrayalloc.asm')
     return output
@@ -2137,7 +2151,7 @@ def __str__(self):
     'vard': [2, _vard],  # Like the above but with a list of items (chars, bytes or words, hex)
     'lvarx': [3, _lvarx],  # Initializes a local variable. lvard X, (list of bytes): Initializes variable at offset X
     'lvard': [2, _lvard],  # Initializes a local variable. lvard X, (list of bytes): Initializes variable at offset X
-    'larrd': [4, _larrd],  # Initializes a local array
+    'larrd': [5, _larrd],  # Initializes a local array
     'memcopy': [3, _memcopy],  # Copies a block of param 3 bytes of memory from param 2 addr to param 1 addr.
 
     'bandu8': [3, _band8],  # x = A & B

arch/zx48k/translator.py

@@ -21,6 +21,7 @@
 from api.errors import InvalidOperatorError
 from api.errors import InvalidBuiltinFunctionError
 from api.errors import InternalError
+from zxbpp import zxbpp
 
 from . import backend
 from .backend.__float import _float
@@ -36,6 +37,7 @@
            'FunctionTranslator']
 
 JumpTable = namedtuple('JumpTable', ('label', 'addresses'))
+LabelledData = namedtuple('LabelledData', ('label', 'data'))
 
 
 class Translator(TranslatorVisitor):
@@ -1305,7 +1307,9 @@ def visit_LBOUND(self, node):
         elif entry.scope == SCOPE.parameter:
             self.ic_fparam(entry.t, entry.offset)
         elif entry.scope == SCOPE.local:
-            self.ic_fparam(entry.t, -entry.offset)
+            self.ic_paddr(-entry.offset, entry.t)
+            t1 = optemps.new_t()
+            self.ic_fparam(gl.PTR_TYPE, t1)
         self.ic_call('__LBOUND', self.TYPE(gl.BOUND_TYPE).size)
         backend.REQUIRES.add('bound.asm')
 
@@ -1318,7 +1322,9 @@ def visit_UBOUND(self, node):
         elif entry.scope == SCOPE.parameter:
             self.ic_fparam(entry.t, entry.offset)
         elif entry.scope == SCOPE.local:
-            self.ic_fparam(entry.t, -entry.offset)
+            self.ic_paddr(-entry.offset, entry.t)
+            t1 = optemps.new_t()
+            self.ic_fparam(gl.PTR_TYPE, t1)
         self.ic_call('__UBOUND', self.TYPE(gl.BOUND_TYPE).size)
         backend.REQUIRES.add('bound.asm')
 
@@ -1364,6 +1370,8 @@ def start(self):
             self.visit(f)
 
     def visit_FUNCTION(self, node):
+        bound_tables = []
+
         self.ic_label(node.mangled)
         if node.convention == CONVENTION.fastcall:
             self.ic_enter('__fastcall__')
@@ -1378,6 +1386,28 @@ def visit_FUNCTION(self, node):
                 #    return
 
             if local_var.class_ == CLASS.array and local_var.scope == SCOPE.local:
+                bound_ptrs = []  # Bound tables pointers (empty if not used)
+                lbound_label = local_var.mangled + '.__LBOUND__'
+                ubound_label = local_var.mangled + '.__UBOUND__'
+
+                if local_var.lbound_used or local_var.ubound_used:
+                    bound_ptrs = ['0', '0']  # NULL by default
+                    if local_var.lbound_used:
+                        bound_ptrs[0] = lbound_label
+                    if local_var.ubound_used:
+                        bound_ptrs[1] = ubound_label
+
+                if bound_ptrs:
+                    zxbpp.ID_TABLE.define('__ZXB_USE_LOCAL_ARRAY_WITH_BOUNDS__', lineno=0)
+
+                if local_var.lbound_used:
+                    l = ['%04X' % bound.lower for bound in local_var.bounds]
+                    bound_tables.append(LabelledData(lbound_label, l))
+
+                if local_var.ubound_used:
+                    l = ['%04X' % bound.upper for bound in local_var.bounds]
+                    bound_tables.append(LabelledData(ubound_label, l))
+
                 l = [len(local_var.bounds) - 1] + [x.count for x in local_var.bounds[1:]]  # TODO Check this
                 q = []
                 for x in l:
@@ -1388,7 +1418,7 @@ def visit_FUNCTION(self, node):
                 r = []
                 if local_var.default_value is not None:
                     r.extend(self.array_default_value(local_var.type_, local_var.default_value))
-                self.ic_larrd(local_var.offset, q, local_var.size, r)  # Initializes array bounds
+                self.ic_larrd(local_var.offset, q, local_var.size, r, bound_ptrs)  # Initializes array bounds
             elif local_var.class_ == CLASS.const:
                 continue
             else:  # Local vars always defaults to 0, so if 0 we do nothing
@@ -1451,6 +1481,9 @@ def visit_FUNCTION(self, node):
         else:
             self.ic_leave(node.params.size)
 
+        for bound_table in bound_tables:
+            self.ic_vard(bound_table.label, bound_table.data)
+
     def visit_FUNCDECL(self, node):
         """ Nested scope functions
         """

arch/zx48k/translatorinstvisitor.py

@@ -127,8 +127,8 @@ def ic_jzero(self, type_, t, label: str):
     def ic_label(self, label: str):
         return self.emit('label', label)
 
-    def ic_larrd(self, offset, arg1, size, arg2):
-        return self.emit('larrd', offset, arg1, size, arg2)
+    def ic_larrd(self, offset, arg1, size, arg2, bound_ptrs):
+        return self.emit('larrd', offset, arg1, size, arg2, bound_ptrs)
 
     def ic_le(self, type_, t, t1, t2):
         return self.emit('le' + self.TSUFFIX(type_), t, t1, t2)

library-asm/arrayalloc.asm

@@ -45,19 +45,92 @@ __ALLOC_LOCAL_ARRAY:
 ;  HL = Offset to be added to IX => HL = IX + HL
 ;  BC = Length of the element area = n.elements * size(element)
 ;  DE = PTR to the index table
-;  TOP of the stack = PTR to the element area
+;  [SP + 2] = PTR to the element area
+;
 ; Returns:
-;  Nothing
+;  HL = (IX + HL) + 4
 ; ---------------------------------------------------------------------
 
 __ALLOC_INITIALIZED_LOCAL_ARRAY:
     push bc
     call __ALLOC_LOCAL_ARRAY
     pop bc
-    pop hl
-    ex (sp), hl
+    ;; Swaps [SP], [SP + 2]
+    exx
+    pop hl       ; HL <- RET address
+    ex (sp), hl  ; HL <- Data table, [SP] <- RET address
+    push hl      ; [SP] <- Data table
+    exx
+    ex (sp), hl  ; HL = Data table, (SP) = (IX + HL + 4) - start of array address lbound
     ; HL = data table
     ; BC = length
     ; DE = new data area
     ldir
+    pop hl  ; HL = addr of LBound area if used
+    ret
+
+
+#ifdef __ZXB_USE_LOCAL_ARRAY_WITH_BOUNDS__
+
+; ---------------------------------------------------------------------
+; __ALLOC_LOCAL_ARRAY_WITH_BOUNDS
+;  Allocates an array element area in the heap, and clears it filling it
+;  with 0 bytes. Then sets LBOUND and UBOUND ptrs
+;
+; Parameters
+;  HL = Offset to be added to IX => HL = IX + HL
+;  BC = Length of the element area = n.elements * size(element)
+;  DE = PTR to the index table
+;  [SP + 2] PTR to the lbound element area
+;  [SP + 4] PTR to the ubound element area
+;
+; Returns:
+;  HL = (IX + HL) + 8
+; ---------------------------------------------------------------------
+__ALLOC_LOCAL_ARRAY_WITH_BOUNDS:
+    call __ALLOC_LOCAL_ARRAY
+
+__ALLOC_LOCAL_ARRAY_WITH_BOUNDS2:
+    pop bc   ;; ret address
+    pop de   ;; lbound
+    inc hl
+    ld (hl), e
+    inc hl
+    ld (hl), d
+    pop de
+    inc hl
+    ld (hl), e
+    inc hl
+    ld (hl), d
+    push bc
     ret
+
+
+; ---------------------------------------------------------------------
+; __ALLOC_INITIALIZED_LOCAL_ARRAY_WITH_BOUNDS
+;  Allocates an array element area in the heap, and clears it filling it
+;  with 0 bytes
+;
+; Parameters
+;  HL = Offset to be added to IX => HL = IX + HL
+;  BC = Length of the element area = n.elements * size(element)
+;  DE = PTR to the index table
+;  TOP of the stack = PTR to the element area
+;  [SP + 2] = PTR to the element area
+;  [SP + 4] = PTR to the lbound element area
+;  [SP + 6] = PTR to the ubound element area
+;
+; Returns:
+;  HL = (IX + HL) + 8
+; ---------------------------------------------------------------------
+__ALLOC_INITIALIZED_LOCAL_ARRAY_WITH_BOUNDS:
+    ;; Swaps [SP] and [SP + 2]
+    exx
+    pop hl       ;; Ret address
+    ex (sp), hl  ;; HL <- PTR to Element area, (sp) = Ret address
+    push hl      ;; [SP] = PTR to element area, [SP + 2] = Ret address
+    exx
+    call __ALLOC_INITIALIZED_LOCAL_ARRAY
+    jp __ALLOC_LOCAL_ARRAY_WITH_BOUNDS2
+
+#endif

symbols/vararray.py

@@ -52,7 +52,7 @@ def size(self):
     def memsize(self):
         """ Total array cell + indexes size
         """
-        return 2 * TYPE.size(gl.PTR_TYPE)
+        return (2 + (2 if self.lbound_used or self.ubound_used else 0)) * TYPE.size(gl.PTR_TYPE)
 
     @property
     def data_label(self):