refact: split symboltable into a Python pkg

Author: boriel

src/api/global_.py

@@ -9,9 +9,6 @@
 #                    the GNU General License
 # ----------------------------------------------------------------------
 from typing import Dict, List, NamedTuple, Optional, Set
-
-import src.api
-
 from src.api.opcodestemps import OpcodesTemps
 from src.api.constants import TYPE, LoopType
 
@@ -82,7 +79,7 @@ class LoopInfo(NamedTuple):
 # ----------------------------------------------------------------------
 # Global Symbol Table
 # ----------------------------------------------------------------------
-SYMBOL_TABLE: Optional["src.api.symboltable.SymbolTable"] = None  # Must be initialized with SymbolTable()
+SYMBOL_TABLE = None  # Must be initialized with SymbolTable instance
 
 # ----------------------------------------------------------------------
 # Function calls pending to check

src/api/optimize.py

@@ -6,6 +6,7 @@
 from typing import Set
 
 import src.api.global_ as gl
+import src.api.symboltable.symboltable
 import src.api.utils
 import src.api.symboltable
 import src.api.check as chk
@@ -478,7 +479,9 @@ def _update_bound_status(self, arg: symbols.VARARRAY):
                 return
 
             if arg.scope == SCOPE.local and not arg.byref:
-                arg.scopeRef.owner.locals_size = src.api.symboltable.SymbolTable.compute_offsets(arg.scopeRef)
+                arg.scopeRef.owner.locals_size = src.api.symboltable.symboltable.SymbolTable.compute_offsets(
+                    arg.scopeRef
+                )
 
 
 class VarDependency(NamedTuple):

src/api/symboltable/__init__.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# vim: ts=4:et:sw=4:
+
+# ----------------------------------------------------------------------
+# Copyleft (K), Jose M. Rodriguez-Rosa (a.k.a. Boriel)
+#
+# This program is Free Software and is released under the terms of
+#                    the GNU General License
+# ----------------------------------------------------------------------
+
+from collections import OrderedDict
+from typing import Optional, Dict
+
+from src.api.config import OPTIONS
+from src.symbols.symbol_ import Symbol
+from src.symbols.var import SymbolVAR
+
+
+class Scope:
+    """Implements a Scope in the SymbolTable
+
+    A Scope is just a dictionary.
+
+    To get a symbol, just access it by it's name. So scope['a'] will
+    return the 'a' symbol (e.g. a declared variable 'a') or None
+    if nothing is declared in that scope (no KeyError exception is raised
+    if the identifier is not defined in such scope).
+
+    The caseins dict stores the symbol names in lowercase only if
+    the global OPTION ignore case is enabled (True). This is because
+    most BASIC dialects are case insensitive. 'caseins' will be used
+    as a fallback if the symbol name does not exists.
+
+    On init() the parent mangle can be stored. The mangle is a prefix
+    added to every symbol to avoid name collision.
+
+    E.g. for a global var o function, the mangle will be '_'. So
+    'a' will be output in asm as '_a'. For nested scopes, the mangled
+    is composed as _function-name_varname. So a local variable in function
+    myFunct will be output as _myFunct_a.
+    """
+
+    def __init__(self, namespace: str = "", parent_scope: Optional["Scope"] = None):
+        self.symbols: Dict[str, SymbolVAR] = OrderedDict()
+        self.caseins: Dict[str, SymbolVAR] = OrderedDict()
+        self.namespace: str = namespace
+        self.owner: Optional[SymbolVAR] = None  # Function, Sub, etc. owning this scope
+        self.parent_scope: Optional["Scope"] = parent_scope
+        self.parent_namespace: Optional[str] = parent_scope.namespace if parent_scope is not None else None
+
+    def __getitem__(self, key: str) -> Optional[SymbolVAR]:
+        return self.symbols.get(key, self.caseins.get(key.lower(), None))
+
+    def __setitem__(self, key: str, value: SymbolVAR):
+        assert isinstance(value, Symbol)
+        self.symbols[key] = value
+        if value.caseins:  # Declared with case insensitive option?
+            self.caseins[key.lower()] = value
+
+    def __delitem__(self, key: str):
+        self.symbols.pop(key, None)
+        self.caseins.pop(key, None)
+
+    def values(self, filter_by_opt=True):
+        if filter_by_opt and OPTIONS.optimization_level > 1:
+            return [y for x, y in self.symbols.items() if y.accessed]
+        return [y for x, y in self.symbols.items()]
+
+    def keys(self, filter_by_opt=True):
+        if filter_by_opt and OPTIONS.optimization_level > 1:
+            return [x for x, y in self.symbols.items() if y.accessed]
+        return self.symbols.keys()
+
+    def items(self, filter_by_opt=True):
+        if filter_by_opt and OPTIONS.optimization_level > 1:
+            return [(x, y) for x, y in self.symbols.items() if y.accessed]
+        return self.symbols.items()

src/api/symboltable/scope.py

@@ -9,101 +9,27 @@
 #                    the GNU General License
 # ----------------------------------------------------------------------
 
-from collections import OrderedDict
-
-from typing import Dict
-from typing import List
-from typing import Optional
-from typing import Union
-
-from src.api import errmsg
-import src.api.check as check
-
-from src.api.debug import __DEBUG__
-from src.api import global_
+from typing import List, Dict, Optional, Union
 
 from src import symbols
+from src.api import global_, check as check, errmsg
+from src.api.config import OPTIONS
+from src.api.constants import TYPE, DEPRECATED_SUFFIXES, SUFFIX_TYPE, CLASS, SCOPE
+from src.api.debug import __DEBUG__
+from src.api.errmsg import (
+    error as syntax_error,
+    warning_not_used,
+    warning_implicit_type,
+    syntax_error_not_array_nor_func,
+    syntax_error_cannot_define_default_array_argument,
+    syntax_error_func_type_mismatch,
+)
+from src.api.symboltable.scope import Scope
+from src.symbols.label import SymbolLABEL
 from src.symbols.symbol_ import Symbol
 from src.symbols.var import SymbolVAR
-from src.symbols.label import SymbolLABEL
 from src.symbols.vararray import SymbolVARARRAY
 
-from .config import OPTIONS
-
-from .errmsg import error as syntax_error
-from .errmsg import warning_implicit_type
-from .errmsg import warning_not_used
-from .errmsg import syntax_error_func_type_mismatch
-from .errmsg import syntax_error_not_array_nor_func
-from .errmsg import syntax_error_cannot_define_default_array_argument
-
-from .constants import DEPRECATED_SUFFIXES
-from .constants import SUFFIX_TYPE
-from .constants import SCOPE
-from .constants import CLASS
-from .constants import TYPE
-
-
-class Scope:
-    """Implements an Scope in the SymbolTable
-
-    An Scope is just a dictionary.
-
-    To get a symbol, just access it by it's name. So scope['a'] will
-    return the 'a' symbol (e.g. a declared variable 'a') or None
-    if nothing is declared in that scope (no KeyError exception is raised
-    if the identifier is not defined in such scope).
-
-    The caseins dict stores the symbol names in lowercase only if
-    the global OPTION ignore case is enabled (True). This is because
-    most BASIC dialects are case insensitive. 'caseins' will be used
-    as a fallback if the symbol name does not exists.
-
-    On init() the parent mangle can be stored. The mangle is a prefix
-    added to every symbol to avoid name collision.
-
-    E.g. for a global var o function, the mangle will be '_'. So
-    'a' will be output in asm as '_a'. For nested scopes, the mangled
-    is composed as _function-name_varname. So a local variable in function
-    myFunct will be output as _myFunct_a.
-    """
-
-    def __init__(self, namespace: str = "", parent_scope: Optional["Scope"] = None):
-        self.symbols: Dict[str, SymbolVAR] = OrderedDict()
-        self.caseins: Dict[str, SymbolVAR] = OrderedDict()
-        self.namespace: str = namespace
-        self.owner: Optional[SymbolVAR] = None  # Function, Sub, etc. owning this scope
-        self.parent_scope: Optional["Scope"] = parent_scope
-        self.parent_namespace: Optional[str] = parent_scope.namespace if parent_scope is not None else None
-
-    def __getitem__(self, key: str) -> Optional[SymbolVAR]:
-        return self.symbols.get(key, self.caseins.get(key.lower(), None))
-
-    def __setitem__(self, key: str, value: SymbolVAR):
-        assert isinstance(value, Symbol)
-        self.symbols[key] = value
-        if value.caseins:  # Declared with case insensitive option?
-            self.caseins[key.lower()] = value
-
-    def __delitem__(self, key: str):
-        self.symbols.pop(key, None)
-        self.caseins.pop(key, None)
-
-    def values(self, filter_by_opt=True):
-        if filter_by_opt and OPTIONS.optimization_level > 1:
-            return [y for x, y in self.symbols.items() if y.accessed]
-        return [y for x, y in self.symbols.items()]
-
-    def keys(self, filter_by_opt=True):
-        if filter_by_opt and OPTIONS.optimization_level > 1:
-            return [x for x, y in self.symbols.items() if y.accessed]
-        return self.symbols.keys()
-
-    def items(self, filter_by_opt=True):
-        if filter_by_opt and OPTIONS.optimization_level > 1:
-            return [(x, y) for x, y in self.symbols.items() if y.accessed]
-        return self.symbols.items()
-
 
 class SymbolTable:
     """Implements a symbol table.

src/api/symboltable.py src/api/symboltable/symboltable.pysrc/api/symboltable.py renamed to src/api/symboltable/symboltable.py

@@ -8,9 +8,8 @@
 # This program is Free Software and is released under the terms of
 #                    the GNU General License
 # ----------------------------------------------------------------------
-
+import src.api.symboltable.scope
 from src.api import global_
-from src.api import symboltable
 from src.api.constants import CLASS
 
 from src.symbols.symbol_ import Symbol
@@ -52,7 +51,7 @@ def local_symbol_table(self):
 
     @local_symbol_table.setter
     def local_symbol_table(self, value):
-        assert isinstance(value, symboltable.Scope)
+        assert isinstance(value, src.api.symboltable.scope.Scope)
         self.entry.local_symbol_table = value
 
     @property

src/symbols/funcdecl.py

@@ -25,6 +25,7 @@
 from typing import Optional
 
 # Compiler API
+import src.api.symboltable.symboltable
 from src.api.debug import __DEBUG__  # analysis:ignore
 from src.api.opcodestemps import OpcodesTemps
 from src.api.errmsg import error
@@ -93,7 +94,7 @@
 # ----------------------------------------------------------------------
 # Global Symbol Table
 # ----------------------------------------------------------------------
-SYMBOL_TABLE = gl.SYMBOL_TABLE = src.api.symboltable.SymbolTable()
+SYMBOL_TABLE = gl.SYMBOL_TABLE = src.api.symboltable.symboltable.SymbolTable()
 
 # ----------------------------------------------------------------------
 # Defined user labels. They all are prepended _label_. Line numbers 10,
@@ -155,7 +156,7 @@ def init():
     del gl.FUNCTION_CALLS[:]
     del gl.FUNCTION_LEVEL[:]
     del gl.FUNCTIONS[:]
-    SYMBOL_TABLE = gl.SYMBOL_TABLE = src.api.symboltable.SymbolTable()
+    SYMBOL_TABLE = gl.SYMBOL_TABLE = src.api.symboltable.symboltable.SymbolTable()
     OPTIONS = src.api.config.OPTIONS
 
     # DATAs info

src/zxbc/zxbparser.py

@@ -5,7 +5,7 @@
 from unittest import TestCase
 from io import StringIO
 
-from src.api.symboltable import SymbolTable
+from src.api.symboltable.symboltable import SymbolTable
 from src.api.constants import TYPE
 from src.api.constants import SCOPE
 from src.api.constants import CLASS

tests/api/test_symbolTable.py

@@ -7,7 +7,7 @@
 from src import symbols
 import src.api.global_ as gl
 import src.api.config as config
-from src.api.symboltable import SymbolTable
+from src.api.symboltable.symboltable import SymbolTable
 from src.symbols.type_ import Type
 from src.zxbpp import zxbpp
 

tests/symbols/test_symbolARRAYACCESS.py

@@ -5,6 +5,7 @@
 from unittest import TestCase
 import src.api.global_ as gl
 import src.api.symboltable
+import src.api.symboltable.symboltable
 from src.api.constants import CLASS
 
 from src.symbols import FUNCDECL
@@ -13,7 +14,7 @@
 
 class TestSymbolFUNCDECL(TestCase):
     def setUp(self):
-        src.api.global_.SYMBOL_TABLE = src.api.symboltable.SymbolTable()
+        src.api.global_.SYMBOL_TABLE = src.api.symboltable.symboltable.SymbolTable()
         self.f = gl.SYMBOL_TABLE.declare_func("f", 1, type_=Type.ubyte)
         self.s = FUNCDECL(self.f, 1)