Debug: update PyCortexMDebug to latest and refactor (#574)

* Debug: update PyCortexDebug to latest and refactor.
* Debug: format sources. Dockerfile: add missing dependency. Make: switch to gdb-py.
* Debug: port PyCortexMDebug to python2
* Docker: add missing debug dependencies
* Debug: cleanup local include in svd_gdb.py

debug/PyCortexMDebug/cmdebug/svd.py

@@ -1,3 +1,4 @@
+#!/usr/bin/env python
 """
 This file is part of PyCortexMDebug
 
@@ -15,13 +16,92 @@ You should have received a copy of the GNU General Public License
 along with PyCortexMDebug.  If not, see <http://www.gnu.org/licenses/>.
 """
 
-
 import lxml.objectify as objectify
 import sys
-from copy import deepcopy
 from collections import OrderedDict
 import os
+import pickle
 import traceback
+import re
+import warnings
+
+
+class SmartDict:
+    """
+    Dictionary for search by case-insensitive lookup and/or prefix lookup
+    """
+
+    def __init__(self):
+        self.od = OrderedDict()
+        self.casemap = {}
+
+    def __getitem__(self, key):
+        if key in self.od:
+            return self.od[key]
+
+        if key.lower() in self.casemap:
+            return self.od[self.casemap[key.lower()]]
+
+        return self.od[self.prefix_match(key)]
+
+    def is_ambiguous(self, key):
+        return (
+            key not in self.od
+            and key not in self.casemap
+            and len(list(self.prefix_match_iter(key))) > 1
+        )
+
+    def prefix_match_iter(self, key):
+        name, number = re.match(r"^(.*?)([0-9]*)$", key.lower()).groups()
+        for entry, od_key in self.casemap.items():
+            if entry.startswith(name) and entry.endswith(number):
+                yield od_key
+
+    def prefix_match(self, key):
+        for od_key in self.prefix_match_iter(key):
+            return od_key
+        return None
+
+    def __setitem__(self, key, value):
+        if key in self.od:
+            warnings.warn("Duplicate entry %s", key)
+        elif key.lower() in self.casemap:
+            warnings.warn(
+                "Entry %s differs from duplicate %s only in cAsE",
+                key,
+                self.casemap[key.lower()],
+            )
+
+        self.casemap[key.lower()] = key
+        self.od[key] = value
+
+    def __delitem__(self, key):
+        if (
+            self.casemap[key.lower()] == key
+        ):  # Check that we did not overwrite this entry
+            del self.casemap[key.lower()]
+        del self.od[key]
+
+    def __contains__(self, key):
+        return key in self.od or key.lower() in self.casemap or self.prefix_match(key)
+
+    def __iter__(self):
+        return iter(self.od)
+
+    def __len__(self):
+        return len(self.od)
+
+    def items(self):
+        return self.od.items()
+
+    def keys(self):
+        return self.od.keys()
+
+    def values(self):
+        return self.od.values()
+
+    def __str__(self):
+        return str(self.od)
 
 
 class SVDNonFatalError(Exception):
@@ -40,29 +120,52 @@ class SVDNonFatalError(Exception):
 
 
 class SVDFile:
+    """
+    A parsed SVD file
+    """
+
     def __init__(self, fname):
+        """
+
+        Args:
+            fname: Filename for the SVD file
+        """
         f = objectify.parse(os.path.expanduser(fname))
         root = f.getroot()
         periph = root.peripherals.getchildren()
-        self.peripherals = OrderedDict()
+        self.peripherals = SmartDict()
+        self.base_address = 0
+
         # XML elements
         for p in periph:
             try:
-                self.peripherals[str(p.name)] = SVDPeripheral(p, self)
+                if p.tag == "peripheral":
+                    self.peripherals[str(p.name)] = SVDPeripheral(p, self)
+                else:
+                    # This is some other tag
+                    pass
             except SVDNonFatalError as e:
                 print(e)
 
 
 def add_register(parent, node):
+    """
+    Add a register node to a peripheral
+
+    Args:
+        parent: Parent SVDPeripheral object
+        node: XML file node fot of the register
+    """
+
     if hasattr(node, "dim"):
         dim = int(str(node.dim), 0)
         # dimension is not used, number of split indexes should be same
         incr = int(str(node.dimIncrement), 0)
         default_dim_index = ",".join((str(i) for i in range(dim)))
         dim_index = str(getattr(node, "dimIndex", default_dim_index))
-        indexes = dim_index.split(",")
+        indices = dim_index.split(",")
         offset = 0
-        for i in indexes:
+        for i in indices:
             name = str(node.name) % i
             reg = SVDPeripheralRegister(node, parent)
             reg.name = name
@@ -71,21 +174,30 @@ def add_register(parent, node):
             offset += incr
     else:
         try:
-            parent.registers[str(node.name)] = SVDPeripheralRegister(node, parent)
-        except:
-            pass
+            reg = SVDPeripheralRegister(node, parent)
+            name = str(node.name)
+            if name not in parent.registers:
+                parent.registers[name] = reg
+            else:
+                if hasattr(node, "alternateGroup"):
+                    print("Register %s has an alternate group", name)
+        except SVDNonFatalError as e:
+            print(e)
 
 
 def add_cluster(parent, node):
+    """
+    Add a register cluster to a peripheral
+    """
     if hasattr(node, "dim"):
         dim = int(str(node.dim), 0)
-        # dimension is not used, number of split indexes should be same
+        # dimension is not used, number of split indices should be same
         incr = int(str(node.dimIncrement), 0)
         default_dim_index = ",".join((str(i) for i in range(dim)))
         dim_index = str(getattr(node, "dimIndex", default_dim_index))
-        indexes = dim_index.split(",")
+        indices = dim_index.split(",")
         offset = 0
-        for i in indexes:
+        for i in indices:
             name = str(node.name) % i
             cluster = SVDRegisterCluster(node, parent)
             cluster.name = name
@@ -101,37 +213,58 @@ def add_cluster(parent, node):
 
 
 class SVDRegisterCluster:
+    """
+    Register cluster
+    """
+
     def __init__(self, svd_elem, parent):
-        self.parent = parent
+        """
+
+        Args:
+            svd_elem: XML element for the register cluster
+            parent: Parent SVDPeripheral object
+        """
+        self.parent_base_address = parent.base_address
+        self.parent_name = parent.name
         self.address_offset = int(str(svd_elem.addressOffset), 0)
-        self.base_address = self.address_offset + parent.base_address
+        self.base_address = self.address_offset + self.parent_base_address
         # This doesn't inherit registers from anything
         children = svd_elem.getchildren()
         self.description = str(svd_elem.description)
         self.name = str(svd_elem.name)
-        self.registers = OrderedDict()
-        self.clusters = OrderedDict()
+        self.registers = SmartDict()
+        self.clusters = SmartDict()
         for r in children:
             if r.tag == "register":
                 add_register(self, r)
 
     def refactor_parent(self, parent):
-        self.parent = parent
-        self.base_address = parent.base_address + self.address_offset
-        try:
-            values = self.registers.itervalues()
-        except AttributeError:
-            values = self.registers.values()
+        self.parent_base_address = parent.base_address
+        self.parent_name = parent.name
+        self.base_address = self.parent_base_address + self.address_offset
+        values = self.registers.values()
         for r in values:
             r.refactor_parent(self)
 
-    def __unicode__(self):
+    def __str__(self):
         return str(self.name)
 
 
 class SVDPeripheral:
+    """
+    This is a peripheral as defined in the SVD file
+    """
+
     def __init__(self, svd_elem, parent):
-        self.parent = parent
+        """
+
+        Args:
+            svd_elem: XML element for the peripheral
+            parent: Parent SVDFile object
+        """
+        self.parent_base_address = parent.base_address
+
+        # Look for a base address, as it is required
         if not hasattr(svd_elem, "baseAddress"):
             raise SVDNonFatalError("Periph without base address")
         self.base_address = int(str(svd_elem.baseAddress), 0)
@@ -139,78 +272,83 @@ class SVDPeripheral:
             derived_from = svd_elem.attrib["derivedFrom"]
             try:
                 self.name = str(svd_elem.name)
-            except:
+            except AttributeError:
                 self.name = parent.peripherals[derived_from].name
             try:
                 self.description = str(svd_elem.description)
-            except:
+            except AttributeError:
                 self.description = parent.peripherals[derived_from].description
-            self.registers = deepcopy(parent.peripherals[derived_from].registers)
-            self.clusters = deepcopy(parent.peripherals[derived_from].clusters)
+
+            # pickle is faster than deepcopy by up to 50% on svd files with a
+            # lot of derivedFrom definitions
+            def copier(a):
+                return pickle.loads(pickle.dumps(a))
+
+            self.registers = copier(parent.peripherals[derived_from].registers)
+            self.clusters = copier(parent.peripherals[derived_from].clusters)
             self.refactor_parent(parent)
         else:
             # This doesn't inherit registers from anything
-            registers = svd_elem.registers.getchildren()
             self.description = str(svd_elem.description)
             self.name = str(svd_elem.name)
-            self.registers = OrderedDict()
-            self.clusters = OrderedDict()
-            for r in registers:
-                if r.tag == "cluster":
-                    add_cluster(self, r)
-                else:
-                    add_register(self, r)
+            self.registers = SmartDict()
+            self.clusters = SmartDict()
+
+            if hasattr(svd_elem, "registers"):
+                registers = [
+                    r
+                    for r in svd_elem.registers.getchildren()
+                    if r.tag in ["cluster", "register"]
+                ]
+                for r in registers:
+                    if r.tag == "cluster":
+                        add_cluster(self, r)
+                    elif r.tag == "register":
+                        add_register(self, r)
 
     def refactor_parent(self, parent):
-        self.parent = parent
-        try:
-            values = self.registers.itervalues()
-        except AttributeError:
-            values = self.registers.values()
+        self.parent_base_address = parent.base_address
+        values = self.registers.values()
         for r in values:
             r.refactor_parent(self)
-        try:
-            for c in self.clusters.itervalues():
-                c.refactor_parent(self)
-        except AttributeError:
-            for c in self.clusters.values():
-                c.refactor_parent(self)
 
-    def __unicode__(self):
+        for c in self.clusters.values():
+            c.refactor_parent(self)
+
+    def __str__(self):
         return str(self.name)
 
 
 class SVDPeripheralRegister:
+    """
+    A register within a peripheral
+    """
+
     def __init__(self, svd_elem, parent):
-        self.parent = parent
+        self.parent_base_address = parent.base_address
         self.name = str(svd_elem.name)
         self.description = str(svd_elem.description)
         self.offset = int(str(svd_elem.addressOffset), 0)
-        try:
+        if hasattr(svd_elem, "access"):
             self.access = str(svd_elem.access)
-        except:
+        else:
             self.access = "read-write"
-        try:
+        if hasattr(svd_elem, "size"):
             self.size = int(str(svd_elem.size), 0)
-        except:
+        else:
             self.size = 0x20
-        self.fields = OrderedDict()
+        self.fields = SmartDict()
         if hasattr(svd_elem, "fields"):
-            fields = svd_elem.fields.getchildren()
+            # Filter fields to only consider those of tag "field"
+            fields = [f for f in svd_elem.fields.getchildren() if f.tag == "field"]
             for f in fields:
                 self.fields[str(f.name)] = SVDPeripheralRegisterField(f, self)
 
     def refactor_parent(self, parent):
-        self.parent = parent
-        try:
-            fields = self.fields.itervalues()
-        except AttributeError:
-            fields = self.fields.values()
-        for f in fields:
-            f.refactor_parent(self)
+        self.parent_base_address = parent.base_address
 
     def address(self):
-        return self.parent.base_address + self.offset
+        return self.parent_base_address + self.offset
 
     def readable(self):
         return self.access in ["read-only", "read-write", "read-writeOnce"]
@@ -223,44 +361,58 @@ class SVDPeripheralRegister:
             "read-writeOnce",
         ]
 
-    def __unicode__(self):
+    def __str__(self):
         return str(self.name)
 
 
 class SVDPeripheralRegisterField:
+    """
+    Field within a register
+    """
+
     def __init__(self, svd_elem, parent):
-        self.parent = parent
         self.name = str(svd_elem.name)
         self.description = str(getattr(svd_elem, "description", ""))
 
-        try:
+        # Try to extract a bit range (offset and width) from the available fields
+        if hasattr(svd_elem, "bitOffset") and hasattr(svd_elem, "bitWidth"):
             self.offset = int(str(svd_elem.bitOffset))
             self.width = int(str(svd_elem.bitWidth))
-        except:
-            try:
-                bitrange = list(
-                    map(int, str(svd_elem.bitRange).strip()[1:-1].split(":"))
-                )
-                self.offset = bitrange[1]
-                self.width = 1 + bitrange[0] - bitrange[1]
-            except:
-                lsb = int(str(svd_elem.lsb))
-                msb = int(str(svd_elem.msb))
-                self.offset = lsb
-                self.width = 1 + msb - lsb
+        elif hasattr(svd_elem, "bitRange"):
+            bitrange = list(map(int, str(svd_elem.bitRange).strip()[1:-1].split(":")))
+            self.offset = bitrange[1]
+            self.width = 1 + bitrange[0] - bitrange[1]
+        else:
+            assert hasattr(svd_elem, "lsb") and hasattr(
+                svd_elem, "msb"
+            ), "Range not found for field {} in register {}".format(self.name, parent)
+            lsb = int(str(svd_elem.lsb))
+            msb = int(str(svd_elem.msb))
+            self.offset = lsb
+            self.width = 1 + msb - lsb
+
         self.access = str(getattr(svd_elem, "access", parent.access))
         self.enum = {}
 
         if hasattr(svd_elem, "enumeratedValues"):
-            for v in svd_elem.enumeratedValues.getchildren():
-                if v.tag == "name":
+            values = [
+                v
+                for v in svd_elem.enumeratedValues.getchildren()
+                if v.tag == "enumeratedValue"
+            ]
+            for v in values:
+                # Skip the "name" tag and any entries that don't have a value
+                if v.tag == "name" or not hasattr(v, "value"):
                     continue
                 # Some Kinetis parts have values with # instead of 0x...
                 value = str(v.value).replace("#", "0x")
-                self.enum[int(value, 0)] = (str(v.name), str(v.description))
-
-    def refactor_parent(self, parent):
-        self.parent = parent
+                description = str(v.description) if hasattr(v, "description") else ""
+                try:
+                    index = int(value, 0)
+                    self.enum[int(value, 0)] = (str(v.name), description)
+                except ValueError:
+                    # If the value couldn't be converted as a single integer, skip it
+                    pass
 
     def readable(self):
         return self.access in ["read-only", "read-write", "read-writeOnce"]
@@ -273,11 +425,15 @@ class SVDPeripheralRegisterField:
             "read-writeOnce",
         ]
 
-    def __unicode__(self):
+    def __str__(self):
         return str(self.name)
 
 
-if __name__ == "__main__":
+def _main():
+    """
+    Basic test to parse a file and do some things
+    """
+
     for f in sys.argv[1:]:
         print("Testing file: {}".format(f))
         svd = SVDFile(f)
@@ -286,3 +442,7 @@ if __name__ == "__main__":
         print("Registers in peripheral '{}':".format(key))
         print(svd.peripherals[key].registers)
         print("Done testing file: {}".format(f))
+
+
+if __name__ == "__main__":
+    _main()