LINKER: partially restored

Author: sipma

chc/linker/CLinker.py

@@ -5,6 +5,8 @@
 # The MIT License (MIT)
 #
 # Copyright (c) 2017-2020 Kestrel Technology LLC
+# Copyright (c) 2020-2023 Henny B. Sipma
+# Copyright (c) 2024      Aarno Labs LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -29,16 +31,27 @@
 
 import xml.etree.ElementTree as ET
 
+from typing import Dict, List, Tuple, TYPE_CHECKING
 
-from chc.linker.CompCompatibility import CompCompatibility
-from chc.app.CCompInfo import CCompInfo
 
-from chc.util.UnionFind import UnionFind
+
+from chc.app.CCompInfo import CCompInfo
+from chc.app.IndexManager import FileKeyReference, FileVarReference
 from chc.app.CGlobalDictionary import CGlobalDictionary
 
+from chc.linker.CompCompatibility import CompCompatibility
+
 import chc.util.fileutil as UF
+from chc.util.loggingutil import chklogger
+from chc.util.UnionFind import UnionFind
 import chc.util.xmlutil as UX
 
+if TYPE_CHECKING:
+    from chc.app.CApplication import CApplication
+    from chc.app.CFile import CFile
+    from chc.app.CGlobalDeclarations import CGlobalDeclarations
+    from chc.app.IndexManager import IndexManager
+
 """
 Starting point: a list of (fileindex,compinfo key) pairs that identify the
    locally declared structs
@@ -54,46 +67,78 @@
 """
 
 
-class CLinker(object):
-    def __init__(self, capp):
-        self.capp = capp  # CApplication
-        self.declarations = self.capp.declarations
+class CLinker:
+    def __init__(self, capp: "CApplication") -> None:
+        self._capp = capp
+        self._compinfos: List["CCompInfo"] = []
+        self._compinfoxrefs: Dict[Tuple[int, int], int] = {}
+        self._varinfoxrefs: Dict[Tuple[int, int], int] = {}
+
+    @property
+    def capp(self) -> "CApplication":
+        return self._capp
+
+    @property
+    def indexmanager(self) -> "IndexManager":
+        return self.capp.indexmanager
+
+    @property
+    def declarations(self) -> "CGlobalDeclarations":
+        return self.capp.declarations
+
+    @property
+    def compinfos(self) -> List["CCompInfo"]:
+        return self._compinfos
 
-    def get_file_compinfo_xrefs(self, fileindex):
-        result = {}
+    @property
+    def compinfoxrefs(self) -> Dict[Tuple[int, int], int]:
+        return self._compinfoxrefs
+
+    @property
+    def varinfoxrefs(self) -> Dict[Tuple[int, int], int]:
+        return self._varinfoxrefs
+
+    def get_file_compinfo_xrefs(self, fileindex: int) -> Dict[int, int]:
+        result: Dict[int, int] = {}
         for (fidx, ckey) in self.compinfoxrefs:
             if fidx == fileindex:
                 result[ckey] = self.compinfoxrefs[(fidx, ckey)]
         return result
 
-    def get_file_varinfo_xrefs(self, fileindex):
-        result = {}
+    def get_file_varinfo_xrefs(self, fileindex: int) -> Dict[int, int]:
+        result: Dict[int, int] = {}
         for (fidx, vid) in self.varinfoxrefs:
             if fidx == fileindex:
                 result[vid] = self.varinfoxrefs[(fidx, vid)]
         return result
 
+    """
     def get_global_compinfos(self):
         return self.compinfoinstances
 
     def get_shared_instances(self):
         return self.sharedinstances
+    """
 
-    def link_compinfos(self):
-        def f(cfile):
-            print("Linking " + cfile.name)
-            compinfos = cfile.declarations.get_compinfos()
+    def link_compinfos(self) -> None:
+
+        chklogger.logger.info("Link compinfos")
+
+        # index and connect the compinfos from the individual files
+        for cfile in self.capp.cfiles:
+            compinfos = cfile.get_compinfos()
             self.declarations.index_file_compinfos(cfile.index, compinfos)
 
-        self.capp.iter_files(f)
+        # register the relationships found with the index manager
         ckey2gckey = self.declarations.ckey2gckey
         for fid in ckey2gckey:
             for ckey in ckey2gckey[fid]:
                 gckey = ckey2gckey[fid][ckey]
-                self.capp.indexmanager.add_ckey2gckey(fid, ckey, gckey)
+                filekey = FileKeyReference(fid, ckey)
+                self.capp.indexmanager.add_ckey2gckey(filekey, gckey)
 
     """
-    def linkcompinfos(self):
+    def linkcompinfos(self) -> None:
         self._checkcompinfopairs()
 
         print('Found ' + str(len(self.possiblycompatiblestructs)) +
@@ -144,10 +189,11 @@ def linkcompinfos(self):
             else:
                 filename = self.capp.getfilebyindex(id[0]).getfilename()
                 self.sharedinstances[gckey].append((filename,c))
+
     """
 
-    def link_varinfos(self):
-        def f(cfile):
+    def link_varinfos(self) -> None:
+        def f(cfile: "CFile") -> None:
             varinfos = cfile.declarations.get_global_varinfos()
             self.declarations.index_file_varinfos(cfile.index, varinfos)
 
@@ -157,39 +203,22 @@ def f(cfile):
         for fid in vid2gvid:
             for vid in vid2gvid[fid]:
                 gvid = vid2gvid[fid][vid]
-                self.capp.indexmanager.add_vid2gvid(fid, vid, gvid)
-
-    """
-    def linkvarinfos(self):
-        globalvarinfos = {}
-        for vinfo in self.varinfos:
-            name = vinfo.getname()
-            if vinfo.getstorage() == 'static':
-                fileindex = vinfo.getfile().getindex()
-                name = name + '__file__' + str(fileindex) + '__'
-            if not name in globalvarinfos: globalvarinfos[name] = []
-            globalvarinfos[name].append(vinfo)
-
-        gvid = 1
-        for name in sorted(globalvarinfos):
-            for vinfo in globalvarinfos[name]:
-                id = vinfo.getid()
-                self.varinfoxrefs[id] = gvid
-                self.capp.indexmanager.addvid2gvid(id[0],id[1],gvid)
-            gvid += 1
-    """
+                filevar = FileVarReference(fid, vid)
+                self.indexmanager.add_vid2gvid(filevar, gvid)
 
-    def save_global_compinfos(self):
-        path = self.capp.path
+    def save_global_compinfos(self) -> None:
+        path = self.capp.targetpath
         xroot = UX.get_xml_header("globals", "globals")
         xnode = ET.Element("globals")
         xroot.append(xnode)
         self.declarations.write_xml(xnode)
-        filename = UF.get_global_definitions_filename(path)
+        filename = UF.get_global_definitions_filename(path, self.capp.projectname)
+        chklogger.logger.info("Saving global compinfos to %s", filename)
         with open(filename, "w") as fp:
             fp.write(UX.doc_to_pretty(ET.ElementTree(xroot)))
 
-    def _checkcompinfopairs(self):
+    """
+    def _checkcompinfopairs(self) -> None:
         self.possiblycompatiblestructs = []
         compinfos = sorted(self.compinfos, key=lambda c: c.getid())
         print(
@@ -209,3 +238,4 @@ def _checkcompinfopairs(self):
                     self.possiblycompatiblestructs.append(pair)
                 else:
                     self.notcompatiblestructs.add(pair)
+    """

chc/linker/CompCompatibility.py

@@ -4,7 +4,9 @@
 # ------------------------------------------------------------------------------
 # The MIT License (MIT)
 #
-# Copyright (c) 2017 Kestrel Technology LLC
+# Copyright (c) 2017-2019  Kestrel Technology LLC
+# Copyright (c) 2020-2024  Henny B. Sipma
+# Copyright (c) 2024       Aarno Labs LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -25,53 +27,75 @@
 # SOFTWARE.
 # ------------------------------------------------------------------------------
 
+from typing import Iterator, List, Set, Tuple, TYPE_CHECKING
 
-class CompCompatibility(object):
+if TYPE_CHECKING:
+    from chc.app.CCompInfo import CCompInfo
+    from chc.app.CFieldInfo import CFieldInfo
+
+
+class CompCompatibility:
     """Determines compatibility between two structs."""
 
-    def __init__(self, comp1, comp2):
-        self.comp1 = comp1  # CCompInfo
-        self.comp2 = comp2  # CCompInfo
+    def __init__(self, comp1: "CCompInfo", comp2: "CCompInfo") -> None:
+        self._comp1 = comp1
+        self._comp2 = comp2
+
+    @property
+    def comp1(self) -> "CCompInfo":
+        return self._comp1
+
+    @property
+    def comp2(self) -> "CCompInfo":
+        return self._comp2
 
-    """Return true if they have the same fields (but not necessarily compatible field types)"""
+    def are_structurally_compatible(self) -> bool:
+        """Returns true if comp1 and comp2 have the same fields.
 
-    def are_structurally_compatible(self):
-        if self.comp1.getfieldcount() == self.comp2.getfieldcount():
-            return set(self.comp1.getfieldnames()) == set(self.comp2.getfieldnames())
+        Note: The field types are not necessarily compatible.
+        """
+        if self.comp1.fieldcount == self.comp2.fieldcount:
+            return set(self.comp1.fieldnames) == set(self.comp2.fieldnames)
         return False
 
-    """Return true if they are structurally compatible and if the types of their fields
-    are structurally compatible, taking into account a list of pairs of struct tags
-    that are explicitly declared incompatible."""
+    def are_shallow_compatible(
+            self, incompatibles: Set[Tuple[str, str]] = set([])) -> bool:
+        """Returns true if comp1 and comp2 are structurally compatible.
 
-    def are_shallow_compatible(self, incompatibles=set([])):
+        Note: This means the the types of comp1 and comp2 are structurally
+        compatible taking into account a list of pairs of struct tags that
+        are explicitly declared incompatible.
+        """
         if self.are_structurally_compatible():
             return self._forall_shallowcompatiblefieldtype(incompatibles)
         return False
 
-    def __str__(self):
-        if self.comp1.getid() == self.comp2.getid():
+    def __str__(self) -> str:
+        if self.comp1.index == self.comp2.index:
             return "identical"
         if self.are_shallow_compatible():
             return "shallow compatible (without incompatibles declared)"
         if self.are_structurally_compatible():
             return self._find_incompatiblefieldtype()
         return "not structurally compatible"
 
-    def _find_incompatiblefieldtype(self):
-        fieldpairs = zip(sorted(self.comp1.getfields()), sorted(self.comp2.getfields()))
-        for ((_, finfo1), (_, finfo2)) in fieldpairs:
-            t1 = finfo1.gettype()
-            t2 = finfo2.gettype()
-            if not t1.shallowcompatible(t2):
+    def _find_incompatiblefieldtype(self) -> str:
+        fieldpairs: Iterator[Tuple["CFieldInfo", "CFieldInfo"]] = zip(
+            self.comp1.fields, self.comp2.fields)
+        for (finfo1, finfo2) in fieldpairs:
+            t1 = finfo1.ftype
+            t2 = finfo2.ftype
+            if not t1.equal(t2):
                 return "t1: " + str(t1) + "\nt2: " + str(t2)
         return "no incompatible fields found"
 
-    def _forall_shallowcompatiblefieldtype(self, incompatibles=set([])):
-        fieldpairs = zip(sorted(self.comp1.getfields()), sorted(self.comp2.getfields()))
-        for ((_, finfo1), (_, finfo2)) in fieldpairs:
-            t1 = finfo1.gettype().expand()
-            t2 = finfo2.gettype().expand()
-            if not t1.shallowcompatible(t2, incompatibles):
+    def _forall_shallowcompatiblefieldtype(
+            self, incompatibles: Set[Tuple[str, str]] = set([])) -> bool:
+        fieldpairs: Iterator[Tuple["CFieldInfo", "CFieldInfo"]] = zip(
+            self.comp1.fields, self.comp2.fields)
+        for (finfo1, finfo2) in fieldpairs:
+            t1 = finfo1.ftype.expand()
+            t2 = finfo2.ftype.expand()
+            if not t1.equal(t2):
                 return False
         return True