feature: implement temporary labels in zxbasm

Author: boriel

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

@@ -274,6 +274,12 @@ def t_BIN(self, t):
         t.type = 'INTEGER'
         return t
 
+    def t_INITIAL_TMPLABEL(self, t):
+        r'[0-9]+[FfBb]'
+        t.type = 'ID'
+        t.value = t.value.upper()
+        return t
+
     def t_INITIAL_preproc_INTEGER(self, t):
         r'[0-9]+'  # an integer decimal number
         t.value = int(t.value)

src/zxbasm/asmlex.py

@@ -143,8 +143,9 @@ def p_asms_asms_asm(p):
 
 def p_asm_label(p):
     """ asm : ID
+            | INTEGER
     """
-    MEMORY.declare_label(p[1], p.lineno(1))
+    MEMORY.declare_label(str(p[1]), p.lineno(1))
 
 
 def p_asm_ld8(p):

src/zxbasm/asmparse.py

@@ -1,6 +1,5 @@
 from src.api.errmsg import error
 from src.zxbasm import global_ as asm_gl
-from src.zxbasm import expr
 
 
 class Label:
@@ -31,7 +30,7 @@ def defined(self):
         """
         return self.value is not None
 
-    def define(self, value, lineno, namespace=None):
+    def define(self, value, lineno: int, namespace=None):
         """ Defines label value. It can be anything. Even an AST
         """
         if self.defined:
@@ -41,21 +40,22 @@ def define(self, value, lineno, namespace=None):
         self.lineno = lineno
         self.namespace = asm_gl.NAMESPACE if namespace is None else namespace
 
-    def resolve(self, lineno):
-        """ Evaluates label value. Exits with error (unresolved) if value is none
-        """
-        if not self.defined:
-            error(lineno, "Undeclared label '%s'" % self.name)
-
-        if isinstance(self.value, expr.Expr):
-            return self.value.eval()
-
-        return self.value
-
     @property
     def is_temporary(self):
-        return self._name.isdecimal()
+        return self._name[0].isdecimal()
+
+    @property
+    def direction(self) -> int:
+        """ Direction to search for this label (-1, 1)
+        """
+        return 0 if not self.is_temporary else {'B': -1, 'F': 1}.get(self._name[-1], 0)
 
     @property
     def name(self):
-        return self._name
+        return self._name if not self.is_temporary else self._name.strip('BF')
+
+    def __eq__(self, other):
+        if isinstance(other, Label):
+            return other.name == self.name and other.namespace == self.namespace
+
+        return False

src/zxbasm/label.py

@@ -1,4 +1,5 @@
 from collections import defaultdict
+from bisect import bisect_left, bisect_right
 from typing import Dict, List, Optional, Tuple
 
 from src.api import global_ as gl
@@ -16,6 +17,8 @@ class Memory:
     """ A class to describe memory
     """
     MAX_MEM = 65535  # Max memory limit
+    _tmp_labels: Dict[int, Dict[str, Label]]
+    _tmp_labels_lines: List[int]
 
     def __init__(self, org: int = 0):
         """ Initializes the origin of code.
@@ -24,10 +27,9 @@ def __init__(self, org: int = 0):
         self.memory_bytes: Dict[int, int] = {}  # An array (associative) containing memory bytes
         self.local_labels: List[Dict[str, Label]] = [{}]  # Local labels in the current memory scope
         self.global_labels = self.local_labels[0]  # Global memory labels
-        self.tmp_labels: Dict[int, Dict[str, Label]] = defaultdict(dict)
-        self.tmp_labels_lines: List[int] = []
         self.ORG = org  # last ORG value set
         self.scopes: List[int] = []
+        self.clear_temporary_labels()
 
         # Origins of code for asm mnemonics.
         # This will store corresponding asm instructions
@@ -38,6 +40,7 @@ def enter_proc(self, lineno: int):
         """
         self.local_labels.append({})  # Add a new context
         self.scopes.append(lineno)
+        self.clear_temporary_labels()
         __DEBUG__('Entering scope level %i at line %i' % (len(self.scopes), lineno))
 
     def set_org(self, value: int, lineno: int):
@@ -46,6 +49,7 @@ def set_org(self, value: int, lineno: int):
         if value < 0 or value > self.MAX_MEM:
             error(lineno, "Memory ORG out of range [0 .. 65535]. Current value: %i" % value)
 
+        self.clear_temporary_labels()
         self.index = self.ORG = value
 
     @staticmethod
@@ -57,7 +61,8 @@ def id_name(label: str, namespace: Optional[str] = None) -> Tuple[str, str]:
         if namespace is None:
             namespace = asm_gl.NAMESPACE
 
-        if label.isdecimal():  # temporary labels are just integer numbers
+        # temporary labels are just integer numbers
+        if label.isdecimal() or label[-1] in 'BF' and label[:-1].isdecimal():
             return label, namespace
 
         if not label.startswith(DOT):
@@ -85,6 +90,7 @@ def __set_byte(self, byte: int, lineno: int):
     def exit_proc(self, lineno: int):
         """ Exits current procedure. Local labels are transferred to global
         scope unless they have been marked as local ones.
+        Temporary labels are "forgotten", and used ones must be resolved at this point.
 
         Raises an error if no current local context (stack underflow)
         """
@@ -112,12 +118,31 @@ def exit_proc(self, lineno: int):
 
         self.local_labels.pop()  # Removes current context
         self.scopes.pop()
+        self.clear_temporary_labels()
 
     def set_memory_slot(self):
         if self.org not in self.orgs:
             self.orgs[self.org] = []  # Declares an empty memory slot if not already done
             self.memory_bytes[self.org] = 0  # Declares an empty memory slot if not already done
 
+    def resolve_temporary_label(self, label: Label):
+        if label.direction == -1:
+            idx = bisect_right(self._tmp_labels_lines, label.lineno)
+            for line in self._tmp_labels_lines[:idx][::-1]:
+                if label == self._tmp_labels[line].get(label.name):
+                    label.value = self._tmp_labels[line][label.name].value
+                    return
+        elif label.direction == +1:
+            idx = bisect_left(self._tmp_labels_lines, label.lineno)
+            for line in self._tmp_labels_lines[idx:]:
+                if label == self._tmp_labels[line].get(label.name):
+                    label.value = self._tmp_labels[line][label.name].value
+                    return
+
+    def clear_temporary_labels(self):
+        self._tmp_labels_lines = []
+        self._tmp_labels = defaultdict(dict)
+
     def add_instruction(self, instr: Asm):
         """ This will insert an asm instruction at the current memory position
         in a t-uple as (mnemonic, params).
@@ -142,8 +167,12 @@ def dump(self):
         align = []
 
         for label in self.global_labels.values():
+            if label.is_temporary:
+                self.resolve_temporary_label(label)
+
             if not label.defined:
-                error(label.lineno, "Undefined GLOBAL label '%s'" % label.name)
+                label_type = 'temporary' if label.is_temporary else 'GLOBAL'
+                error(label.lineno, f"Undefined {label_type} label '%s'" % label.name)
 
         for i in range(org, max(self.memory_bytes.keys()) + 1):
             if gl.has_errors:
@@ -201,6 +230,14 @@ def declare_label(
         else:
             __DEBUG__(f"Declaring '{ex_label}' in {lineno}")
 
+        if label.isdecimal():  # Temporary label?
+            assert not self._tmp_labels_lines or self._tmp_labels_lines[-1] <= lineno, "Temporary label out of order"
+            if not self._tmp_labels_lines or self._tmp_labels_lines[-1] != lineno:
+                self._tmp_labels_lines.append(lineno)
+
+            self._tmp_labels[lineno][ex_label] = Label(ex_label, lineno, value, False, namespace, is_address=True)
+            return
+
         if ex_label in self.local_labels[-1].keys():
             self.local_labels[-1][ex_label].define(value, lineno)
             self.local_labels[-1][ex_label].is_address = is_address