Merge pull request #357 from boriel/feature/dependency_propagation

Feature/dependency propagation

Author: boriel

api/identityset.py

@@ -3,7 +3,7 @@
 # vim:ts=4:et:
 
 
-class IdentitySet(object):
+class IdentitySet:
     """ This set implementation only adds items
     if they are not exactly the same (same reference)
     preserving its order (OrderedDict). Allows deleting by ith-index.

api/optimize.py

@@ -6,13 +6,14 @@
 import api.errmsg
 from api.errmsg import warning
 import api.check as chk
-from api.constants import TYPE, SCOPE
+from api.constants import TYPE, SCOPE, CLASS
 import api.global_ as gl
 import symbols
 import types
 from api.debug import __DEBUG__
 from api.errmsg import warning_not_used
 import api.utils
+import api.symboltable
 
 
 class ToVisit(object):
@@ -128,6 +129,7 @@ def visit_FUNCCALL(self, node):
 
     def visit_CALL(self, node):
         node.args = (yield self.generic_visit(node.args))  # Avoid infinite recursion not visiting node.entry
+        self._check_if_any_arg_is_an_array_and_needs_lbound_or_ubound(node.entry.params, node.args)
         yield node
 
     def visit_FUNCDECL(self, node):
@@ -251,3 +253,31 @@ def generic_visit(node):
         for i in range(len(node.children)):
             node.children[i] = (yield ToVisit(node.children[i]))
         yield node
+
+    def _check_if_any_arg_is_an_array_and_needs_lbound_or_ubound(self, params: symbols.PARAMLIST,
+                                                                 args: symbols.ARGLIST):
+        """ Given a list of params and a list of args, traverse them to check if any arg is a byRef array parameter,
+        and if so, whether it's use_lbound or use_ubound flag is updated to True and if it's a local var. If so, it's
+        offset size has changed and must be reevaluated!
+        """
+        for arg, param in zip(args, params):
+            if not param.byref or param.class_ != CLASS.array:
+                continue
+
+            if arg.value.lbound_used and arg.value.ubound_used:
+                continue
+
+            self._update_bound_status(arg.value, param, params.parent)
+
+    def _update_bound_status(self, arg: symbols.VARARRAY, param: symbols.PARAMDECL, func: symbols.FUNCTION):
+        old_lbound_used = arg.lbound_used
+        old_ubound_used = arg.ubound_used
+        arg.lbound_used = arg.lbound_used or param.lbound_used
+        arg.ubound_used = arg.ubound_used or param.ubound_used
+
+        if old_lbound_used != arg.lbound_used or old_ubound_used != arg.ubound_used:
+            if arg.scope == SCOPE.global_:
+                return
+
+            if arg.scope == SCOPE.local and not arg.byref:
+                arg.scopeRef.owner.locals_size = api.symboltable.SymbolTable.compute_offsets(arg.scopeRef)

api/symboltable.py

@@ -91,6 +91,7 @@ def __init__(self, mangle='', parent_mangle=''):
             self.caseins = OrderedDict()
             self.parent_mangle = parent_mangle
             self.mangle = mangle
+            self.ownwer: Symbol = None  # Function, Sub, etc. owning this scope
 
         def __getitem__(self, key):
             return self.symbols.get(key, self.caseins.get(key.lower(), None))
@@ -110,7 +111,6 @@ def __delitem__(self, key):
                 del self.caseins[key.lower()]
 
         def values(self, filter_by_opt=True):
-            # Return the values ordered
             if filter_by_opt and OPTIONS.optimization.value > 1:
                 return [y for x, y in self.symbols.items() if y.accessed]
             return [y for x, y in self.symbols.items()]
@@ -137,7 +137,7 @@ def __init__(self):
             self.basic_types[type_] = self.declare_type(symbols.BASICTYPE(type_))
 
     @property
-    def current_scope(self):
+    def current_scope(self) -> int:
         return len(self.table) - 1
 
     @property
@@ -291,37 +291,25 @@ def enter_scope(self, funcname):
         global_.META_LOOPS.append(global_.LOOPS)  # saves current LOOPS state
         global_.LOOPS = []  # new LOOPS state
 
-    def leave_scope(self):
-        """ Ends a function body and pops current scope out of the symbol table.
-        """
-        def entry_size(entry):
+    @staticmethod
+    def compute_offsets(scope: Scope) -> int:
+
+        def entry_size(var_entry):
             """ For local variables and params, returns the real variable or
             local array size in bytes
             """
-            if entry.scope == SCOPE.global_ or \
-                    entry.is_aliased:  # aliases or global variables = 0
+            if var_entry.scope == SCOPE.global_ or var_entry.is_aliased:  # aliases or global variables = 0
                 return 0
 
-            if entry.class_ != CLASS.array:
-                return entry.size
-
-            return entry.memsize
+            if var_entry.class_ != CLASS.array:
+                return var_entry.size
 
-        for v in self.table[self.current_scope].values(filter_by_opt=False):
-            if not v.accessed:
-                if v.scope == SCOPE.parameter:
-                    kind = 'Parameter'
-                    v.accessed = True  # HINT: Parameters must always be present even if not used!
-                    if not v.byref:  # HINT: byref is always marked as used: it can be used to return a value
-                        warning_not_used(v.lineno, v.name, kind=kind)
+            return var_entry.memsize
 
-        entries = sorted(self.table[self.current_scope].values(filter_by_opt=True), key=entry_size)
+        entries = sorted(scope.values(filter_by_opt=True), key=entry_size)
         offset = 0
 
         for entry in entries:  # Symbols of the current level
-            if entry.class_ is CLASS.unknown:
-                self.move_to_global_scope(entry.name)
-
             if entry.class_ in (CLASS.function, CLASS.label, CLASS.type_):
                 continue
 
@@ -340,6 +328,24 @@ def entry_size(entry):
                 entry.offset = entry_size(entry) + offset
                 offset = entry.offset
 
+        return offset
+
+    def leave_scope(self):
+        """ Ends a function body and pops current scope out of the symbol table.
+        """
+        for v in self.table[self.current_scope].values(filter_by_opt=False):
+            if not v.accessed:
+                if v.scope == SCOPE.parameter:
+                    kind = 'Parameter'
+                    v.accessed = True  # HINT: Parameters must always be present even if not used!
+                    if not v.byref:  # HINT: byref is always marked as used: it can be used to return a value
+                        warning_not_used(v.lineno, v.name, kind=kind)
+
+        for entry in self.table[self.current_scope].values(filter_by_opt=True):  # Symbols of the current level
+            if entry.class_ is CLASS.unknown:
+                self.move_to_global_scope(entry.name)
+
+        offset = self.compute_offsets(self.table[self.current_scope])
         self.mangle = self[self.current_scope].parent_mangle
         self.table.pop()
         global_.LOOPS = global_.META_LOOPS.pop()

ast_/ast.py

@@ -22,7 +22,7 @@ class Ast(Tree):
     pass
 
 
-class NodeVisitor(object):
+class NodeVisitor:
     def visit(self, node):
         stack = [node]
         last_result = None

ast_/tree.py

@@ -1,8 +1,8 @@
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
 
+from typing import Optional
 
-import copy
 import collections
 from api.errors import Error
 
@@ -21,11 +21,13 @@ def __str__(self):
         return self.msg
 
 
-class Tree(object):
+class Tree:
     """ Simple tree implementation
     """
-    class childrenList(object):
-        def __init__(self, node):
+    parent: Optional['Tree'] = None
+
+    class ChildrenList:
+        def __init__(self, node: 'Tree'):
             assert isinstance(node, Tree)
             self.node = node  # Node having this children
             self._children = []
@@ -34,7 +36,7 @@ def __getitem__(self, key):
             if isinstance(key, int):
                 return self._children[key]
 
-            result = Tree.childrenList(self.node)
+            result = Tree.ChildrenList(self.node)
             for x in self._children[key]:
                 result.append(x)
             return result
@@ -68,10 +70,10 @@ def __len__(self):
             return len(self._children)
 
         def __add__(self, other):
-            if not isinstance(other, Tree.childrenList):
+            if not isinstance(other, Tree.ChildrenList):
                 assert isinstance(other, collections.Container)
 
-            result = Tree.childrenList(self.node)
+            result = Tree.ChildrenList(self.node)
             for x in self:
                 result.append(x)
             for x in other:
@@ -82,19 +84,19 @@ def __repr__(self):
             return "%s:%s" % (self.node.__repr__(), str([x.__repr__() for x in self._children]))
 
     def __init__(self):
-        self._children = Tree.childrenList(self)
+        self._children = Tree.ChildrenList(self)
 
     @property
     def children(self):
         return self._children
 
     @children.setter
     def children(self, value):
-        assert isinstance(value, collections.Container)
+        assert isinstance(value, collections.Iterable)
         while len(self.children):
             self.children.pop()
 
-        self._children = Tree.childrenList(self)
+        self._children = Tree.ChildrenList(self)
         for x in value:
             self.children.append(x)
 
@@ -131,24 +133,3 @@ def prependChild(self, node):
         """ Inserts the given node at the beginning of the children list
         """
         self.children.insert(0, node)
-
-    @classmethod
-    def makenode(cls, symbol, *nexts):
-        """ Stores the symbol in an AST instance,
-        and left and right to the given ones
-        """
-        result = cls(symbol)
-        for i in nexts:
-            if i is None:
-                continue
-            if not isinstance(i, cls):
-                raise NotAnAstError(i)
-            result.appendChild(i)
-
-        return result
-
-    def __deepcopy(self, memo):
-        result = Tree(self.symbol)  # No need to duplicate the symbol memory
-        result.next = copy.deepcopy(self.children)
-
-        return result

symbols/arglist.py

@@ -16,10 +16,6 @@
 class SymbolARGLIST(Symbol):
     """ Defines a list of arguments in a function call or array access
     """
-
-    def __init__(self, *args):
-        super(SymbolARGLIST, self).__init__(*args)
-
     @property
     def args(self):
         return self.children

symbols/call.py

@@ -33,14 +33,19 @@ class SymbolCALL(Symbol):
         lineno: source code line where this call was made
     """
 
-    def __init__(self, entry, arglist, lineno):
+    def __init__(self, entry: SymbolFUNCTION, arglist, lineno):
         super(SymbolCALL, self).__init__()
         assert isinstance(lineno, int)
         assert all(isinstance(x, SymbolARGUMENT) for x in arglist)
         self.entry = entry
         self.args = arglist  # Func. call / array access
         self.lineno = lineno
 
+        if entry.token == 'FUNCTION':
+            for arg, param in zip(arglist, entry.params):  # Sets dependency graph for each argument -> parameter
+                if arg.value is not None:
+                    arg.value.add_required_symbol(param)
+
     @property
     def entry(self):
         return self.children[0]

symbols/function.py

@@ -8,6 +8,7 @@
 # This program is Free Software and is released under the terms of
 #                    the GNU General License
 # ----------------------------------------------------------------------
+from typing import Optional
 
 from api.constants import CLASS
 from api.constants import KIND
@@ -52,13 +53,13 @@ def set_kind(self, value, lineno):
         self.__kind = value
 
     @property
-    def params(self):
+    def params(self) -> SymbolPARAMLIST:
         if not self.children:
             return SymbolPARAMLIST()
         return self.children[0]
 
     @params.setter
-    def params(self, value):
+    def params(self, value: SymbolPARAMLIST):
         assert isinstance(value, SymbolPARAMLIST)
         if self.children is None:
             self.children = []
@@ -69,14 +70,14 @@ def params(self, value):
             self.children = [value]
 
     @property
-    def body(self):
+    def body(self) -> SymbolBLOCK:
         if not self.children or len(self.children) < 2:
             self.body = SymbolBLOCK()
 
         return self.children[1]
 
     @body.setter
-    def body(self, value):
+    def body(self, value: Optional[SymbolBLOCK]):
         if value is None:
             value = SymbolBLOCK()
         assert isinstance(value, SymbolBLOCK)