Add typing to preprocessor

Author: boriel

src/libzxbpp/prepro/definestable.py

@@ -9,6 +9,9 @@
 import sys
 import re
 
+from typing import Dict
+from typing import Union
+
 from .id_ import ID
 from .exceptions import PreprocError
 from .output import warning
@@ -17,18 +20,16 @@
 RE_ID = re.compile(r'[a-zA-Z_][a-zA-Z0-9_]*')
 
 
-class DefinesTable(object):
-    """ A class which will store
-    define labels, and its values.
-    It will also susbtitute the current value
-    of a label for the given value.
+class DefinesTable:
+    """ A class which will store define labels, and its values.
+    It will also replace the current value of a label for the given value.
     """
     def __init__(self):
         """ Initializes table
         """
-        self.table = {}
+        self.table: Dict[str, ID] = {}
 
-    def define(self, id_, lineno, value='', fname=None, args=None):
+    def define(self, id_: str, lineno: int, value: str = '', fname: str = None, args=None):
         """ Defines the value of a macro.
         Issues a warning if the macro is already defined.
         """
@@ -44,7 +45,7 @@ def define(self, id_, lineno, value='', fname=None, args=None):
                     (i.name, i.fname, i.lineno))
         self.set(id_, lineno, value, fname, args)
 
-    def set(self, id_, lineno, value='', fname=None, args=None):
+    def set(self, id_: str, lineno: int, value: str = '', fname: str = None, args=None):
         """ Like the above, but issues no warning on duplicate macro
             definitions.
         """
@@ -59,20 +60,20 @@ def undef(self, id_):
         if self.defined(id_):
             del self.table[id_]
 
-    def defined(self, id_):
+    def defined(self, id_: str) -> bool:
         """ Returns if the given ID
         is defined
         """
-        return id_.strip() in self.table.keys()
+        return id_.strip() in self.table
 
-    def __getitem__(self, key):
+    def __getitem__(self, key: str) -> Union[str, ID]:
         """ Returns the ID instance given it's
         _id. If it does not exist, return the _id
         itself.
         """
         return self.table.get(key.strip(), key)
 
-    def __setitem__(self, key, value):
+    def __setitem__(self, key: str, value):
         """ Assigns the value to the given table entry
         """
         k = key.strip()

src/libzxbpp/prepro/id_.py

@@ -7,11 +7,14 @@
 """
 
 import sys
-
 import copy
+
+from typing import Optional
+
 from .macrocall import MacroCall
 from src.api.debug import __DEBUG__
 from .output import CURRENT_FILE
+import src.libzxbpp.prepro as prepro
 
 DEBUG_LEVEL = 3  # Which -d level is required to show debug info
 
@@ -20,7 +23,9 @@ class ID:
     """ This class represents an identifier. It stores a string
     (the ID name and value by default).
     """
-    def __init__(self, id_, args=None, value=None, lineno=None, fname=None):
+    __slots__ = 'name', 'value', 'lineno', 'fname', 'args'
+
+    def __init__(self, id_: str, args=None, value=None, lineno: int = None, fname: str = None):
         if fname is None:
             fname = CURRENT_FILE[-1]
 
@@ -30,30 +35,30 @@ def __init__(self, id_, args=None, value=None, lineno=None, fname=None):
         if not isinstance(value, list):
             value = [value]
 
-        self.name = id_
-        self.value = value
-        self.lineno = lineno  # line number at which de ID was defined
-        self.fname = fname  # file name in which the ID was defined
+        self.name: str = id_
+        self.value: list = value
+        self.lineno: Optional[int] = lineno  # line number at which de ID was defined
+        self.fname: str = fname  # file name in which the ID was defined
         self.args = args
 
     @property
-    def hasArgs(self):
+    def hasArgs(self) -> bool:
         return self.args is not None
 
     def __str__(self):
         return self.name
 
     @staticmethod
-    def __dumptable(table):
+    def __dumptable(table: 'prepro.DefinesTable') -> None:
         """ Dumps table on screen for debugging purposes
         """
-        for x in table.table.keys():
-            sys.stdout.write("{0}\t<--- {1} {2}".format(x, table[x], type(table[x])))
-            if isinstance(table[x], ID):
-                sys.stdout.write(" {0}".format(table[x].value)),
+        for k, v in table.table.items():
+            sys.stdout.write("{0}\t<--- {1} {2}".format(k, v, type(v)))
+            if isinstance(v, ID):
+                sys.stdout.write(" {0}".format(v.value)),
             sys.stdout.write("\n")
 
-    def __call__(self, table):
+    def __call__(self, table) -> str:
         __DEBUG__("evaluating id '%s'" % self.name, DEBUG_LEVEL)
         if self.value is None:
             __DEBUG__("undefined (null) value. BUG?", DEBUG_LEVEL)
@@ -78,7 +83,7 @@ def __call__(self, table):
                 tmp = token(table)
             else:
                 if isinstance(token, ID):
-                    __DEBUG__("token '%s' is an ID" % token.id_, DEBUG_LEVEL)
+                    __DEBUG__("token '%s' is an ID" % token.name, DEBUG_LEVEL)
                     token = token(table)
                 tmp = token
 

src/libzxbpp/prepro/macrocall.py

@@ -6,6 +6,8 @@
 from .exceptions import PreprocError
 from src.api.debug import __DEBUG__
 
+import src.libzxbpp.prepro as prepro
+
 
 DEBUG_LEVEL = 3  # Which -d level is required to show debug info
 
@@ -15,24 +17,26 @@ class MacroCall:
     Every time the macro() is called, the macro returns
     it value.
     """
-    def __init__(self, lineno, table, id_, args=None):
+    __slots__ = 'table', 'id_', 'callargs', 'lineno'
+
+    def __init__(self, lineno: int, table: 'prepro.DefinesTable', id_: str, args=None):
         """ Initializes the object with the ID table, the ID name and
         optionally, the passed args.
         """
-        self.table = table
-        self.id_ = id_
+        self.table: 'prepro.DefinesTable' = table
+        self.id_: str = id_
         self.callargs = args
-        self.lineno = lineno
+        self.lineno: int = lineno
 
     @staticmethod
-    def eval(arg):
+    def eval(arg) -> str:
         """ Evaluates a given argument. The token will be returned by default
         "as is", except if it's a macrocall. In such case it will be evaluated
         recursively.
         """
         return str(arg())  # Evaluate the arg (could be a macrocall)
 
-    def __call__(self, symbolTable=None):
+    def __call__(self, symbolTable: 'prepro.DefinesTable' = None) -> str:
         """ Execute the macro call using LAZY evaluation
         """
         __DEBUG__("evaluating '%s'" % self.id_, DEBUG_LEVEL)
@@ -50,47 +54,49 @@ def __call__(self, symbolTable=None):
 
         # The macro is defined
         __DEBUG__("macro '%s' defined" % self.id_, DEBUG_LEVEL)
-        TABLE = copy.deepcopy(symbolTable)
-        ID = TABLE[self.id_]  # Get the defined macro
-        if ID.hasArgs and self.callargs is None:
+        table = copy.deepcopy(symbolTable)
+        id_ = table[self.id_]  # Get the defined macro
+        assert isinstance(id_, prepro.ID)
+        if id_.hasArgs and self.callargs is None:
             return self.id_  # If no args passed, returned as is
 
+        args = []
         if self.callargs:  # has args. Evaluate them removing spaces
             __DEBUG__("'%s' has args defined" % self.id_, DEBUG_LEVEL)
             __DEBUG__("evaluating %i arg(s) for '%s'" %
                       (len(self.callargs), self.id_), DEBUG_LEVEL)
-            args = [x(TABLE).strip() for x in self.callargs]
+            args = [x(table).strip() for x in self.callargs]
             __DEBUG__("macro call: %s%s" %
                       (self.id_, '(' + ', '.join(args) + ')'), DEBUG_LEVEL)
 
-        if not ID.hasArgs:  # The macro doesn't need args
+        if not id_.hasArgs:  # The macro doesn't need args
             __DEBUG__("'%s' has no args defined" % self.id_, DEBUG_LEVEL)
-            tmp = ID(TABLE)  # If no args passed, returned as is
+            tmp = id_(table)  # If no args passed, returned as is
             if self.callargs is not None:
                 tmp += '(' + ', '.join(args) + ')'
 
             __DEBUG__("evaluation result: %s" % tmp, DEBUG_LEVEL)
             return tmp
 
         # Now ensure both args and callargs have the same length
-        if len(self.callargs) != len(ID.args):
+        if len(self.callargs) != len(id_.args):
             raise PreprocError('Macro "%s" expected %i params, got %i' %
-                               (str(self.id_), len(ID.args),
+                               (str(self.id_), len(id_.args),
                                 len(self.callargs)), self.lineno)
 
         # Carry out unification
         __DEBUG__('carrying out args unification', DEBUG_LEVEL)
         for i in range(len(self.callargs)):
-            __DEBUG__("arg '%s' = '%s'" % (ID.args[i].name, args[i]), DEBUG_LEVEL)
-            TABLE.set(ID.args[i].name, self.lineno, args[i])
+            __DEBUG__("arg '%s' = '%s'" % (id_.args[i].name, args[i]), DEBUG_LEVEL)
+            table.set(id_.args[i].name, self.lineno, args[i])
 
-        tmp = ID(TABLE)
+        tmp = id_(table)
         if '\n' in tmp:
             tmp += '\n#line %i\n' % self.lineno
 
         return tmp
 
-    def is_defined(self, symbolTable=None):
+    def is_defined(self, symbolTable: 'prepro.DefinesTable' = None) -> bool:
         """ True if this macro has been defined
         """
         if symbolTable is None: