Merge pull request #340 from boriel/feature/update_bound

Feature/update bound

Author: boriel

api/symboltable.py

@@ -762,7 +762,6 @@ def declare_array(self, id_, lineno, type_, bounds, default_value=None, addr=Non
         entry.default_value = default_value
         entry.callable = True
         entry.class_ = CLASS.array
-        entry.lbound_used = entry.ubound_used = False  # Flag to true when LBOUND/UBOUND used somewhere in the code
         entry.addr = addr
 
         __DEBUG__('Entry %s declared with class %s at scope %i' % (id_, CLASS.to_string(entry.class_),

arch/zx48k/backend/__init__.py

@@ -498,9 +498,9 @@ def _varx(ins):
 
 def _vard(ins):
     """ Defines a memory space with a default set of bytes/words in hexadecimal
-    (starting with a number) or literals (starting with #).
+    (starting with an hex number) or literals (starting with #).
     Numeric values with more than 2 digits represents a WORD (2 bytes) value.
-    E.g. '01' => 0, '001' => 1, 0 bytes
+    E.g. '01' => 01h, '001' => 1, 0 bytes (0001h)
     Literal values starts with # (1 byte) or ## (2 bytes)
     E.g. '#label + 1' => (label + 1) & 0xFF
          '##(label + 1)' => (label + 1) & 0xFFFF
@@ -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):
@@ -1092,6 +1094,17 @@ def visit_ARRAYDECL(self, node):
             if self.O_LEVEL > 1:
                 return
 
+        bound_ptrs = []  # Bound tables pointers (empty if not used)
+        lbound_label = entry.mangled + '.__LBOUND__'
+        ubound_label = entry.mangled + '.__UBOUND__'
+
+        if entry.lbound_used or entry.ubound_used:
+            bound_ptrs = ['0', '0']  # NULL by default
+            if entry.lbound_used:
+                bound_ptrs[0] = lbound_label
+            if entry.ubound_used:
+                bound_ptrs[1] = ubound_label
+
         data_label = entry.data_label
         idx_table_label = backend.tmp_label()
         l = ['%04X' % (len(node.bounds) - 1)]  # Number of dimensions - 1
@@ -1118,21 +1131,23 @@ def visit_ARRAYDECL(self, node):
 
         if entry.addr:
             self.ic_varx(entry.data_ptr_label, gl.PTR_TYPE, [self.traverse_const(entry.addr)])
+            if bound_ptrs:
+                self.ic_data(gl.PTR_TYPE, bound_ptrs)
         else:
             self.ic_varx(entry.data_ptr_label, gl.PTR_TYPE, [data_label])
+            if bound_ptrs:
+                self.ic_data(gl.PTR_TYPE, bound_ptrs)
             self.ic_vard(data_label, arr_data)
 
         self.ic_vard(idx_table_label, l)
 
         if entry.lbound_used:
-            l = ['%04X' % len(node.bounds)] + \
-                ['%04X' % bound.lower for bound in node.bounds]
-            self.ic_vard('__LBOUND__.' + entry.mangled, l)
+            l = ['%04X' % bound.lower for bound in node.bounds]
+            self.ic_vard(lbound_label, l)
 
         if entry.ubound_used:
-            l = ['%04X' % len(node.bounds)] + \
-                ['%04X' % bound.upper for bound in node.bounds]
-            self.ic_vard('__UBOUND__.' + entry.mangled, l)
+            l = ['%04X' % bound.upper for bound in node.bounds]
+            self.ic_vard(ubound_label, l)
 
 
 class UnaryOpTranslator(TranslatorVisitor):
@@ -1284,19 +1299,33 @@ def visit_SQR(self, node):
     # endregion
 
     def visit_LBOUND(self, node):
-        entry = node.operands[0]
-        self.ic_param(gl.BOUND_TYPE, '#__LBOUND__.' + entry.mangled)
         yield node.operands[1]
-        self.ic_fparam(gl.BOUND_TYPE, optemps.new_t())
-        self.ic_call('__BOUND', self.TYPE(gl.BOUND_TYPE).size)
+        self.ic_param(gl.BOUND_TYPE, node.operands[1].t)
+        entry = node.operands[0]
+        if entry.scope == SCOPE.global_:
+            self.ic_fparam(gl.PTR_TYPE, '#{}'.format(entry.mangled))
+        elif entry.scope == SCOPE.parameter:
+            self.ic_fparam(entry.t, entry.offset)
+        elif entry.scope == SCOPE.local:
+            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')
 
     def visit_UBOUND(self, node):
-        entry = node.operands[0]
-        self.ic_param(gl.BOUND_TYPE, '#__UBOUND__.' + entry.mangled)
         yield node.operands[1]
-        self.ic_fparam(gl.BOUND_TYPE, optemps.new_t())
-        self.ic_call('__BOUND', self.TYPE(gl.BOUND_TYPE).size)
+        self.ic_param(gl.BOUND_TYPE, node.operands[1].t)
+        entry = node.operands[0]
+        if entry.scope == SCOPE.global_:
+            self.ic_fparam(gl.PTR_TYPE, '#{}'.format(entry.mangled))
+        elif entry.scope == SCOPE.parameter:
+            self.ic_fparam(entry.t, entry.offset)
+        elif entry.scope == SCOPE.local:
+            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')
 
     def visit_USR_STR(self, node):
@@ -1341,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__')
@@ -1355,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:
@@ -1365,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
@@ -1428,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