Merge pull request cmsis-svd#56 from stefanhoelzl/cluster-support

Cluster support

Author: posborne

python/cmsis_svd/model.py

@@ -282,6 +282,165 @@ def is_reserved(self):
         return 'reserved' in self.name.lower()
 
 
+class SVDRegisterCluster(SVDElement):
+    """Represent a register cluster in the tree"""
+
+    def __init__(self, name, derived_from, description, address_offset, size,
+                 alternate_cluster, header_struct_name,
+                 access, protection, reset_value, reset_mask, register,
+                 cluster):
+        SVDElement.__init__(self)
+
+        # When deriving a register, it is mandatory to specify at least the name, the description,
+        # and the addressOffset
+        self.derived_from = derived_from
+        self.name = name
+        self.description = description
+        self.address_offset = address_offset
+
+        self._alternate_cluster = alternate_cluster
+        self._header_struct_name = header_struct_name
+        self._size = size
+        self._access = access
+        self._protection = protection
+        self._reset_value = reset_value
+        self._reset_mask = reset_mask
+        self._register = register
+        self._cluster = cluster
+
+        # make parent association
+        for cluster in self._cluster:
+            cluster.parent = self
+
+    def __getattr__(self, attr):
+        return self._lookup_possibly_derived_attribute(attr)
+
+    def updated_register(self, reg, clu):
+        new_reg = SVDRegister(
+            name="{}_{}".format(clu.name, reg.name),
+            fields=reg.fields,
+            derived_from=reg.derived_from,
+            description=reg.description,
+            address_offset=clu.address_offset + reg.address_offset,
+            size=reg.size,
+            access=reg.access,
+            protection=reg.protection,
+            reset_value=reg.reset_value,
+            reset_mask=reg.reset_mask,
+            display_name=reg.display_name,
+            alternate_group=reg.alternate_group,
+            modified_write_values=reg.modified_write_values,
+            read_action=reg.read_action,
+        )
+        new_reg.parent = self
+        return new_reg
+
+    @property
+    def registers(self):
+        for reg in self._register:
+            yield self.updated_register(reg, self)
+        for cluster in self._cluster:
+            for reg in cluster.registers:
+                yield self.updated_register(reg, self)
+
+    def get_derived_from(self):
+        # TODO: add support for dot notation derivedFrom
+        if self.derived_from is None:
+            return None
+
+        for register in self.parent.registers:
+            if register.name == self.derived_from:
+                return register
+
+        raise KeyError("Unable to find derived_from: %r" % self.derived_from)
+
+    def is_reserved(self):
+        return 'reserved' in self.name.lower()
+
+
+class SVDRegisterClusterArray(SVDElement):
+    """Represent a register cluster in the tree"""
+
+    def __init__(self, name, derived_from, description, address_offset, size,
+                 alternate_cluster, header_struct_name,
+                 dim, dim_indices, dim_increment,
+                 access, protection, reset_value, reset_mask, register,
+                 cluster):
+        SVDElement.__init__(self)
+
+        # When deriving a register, it is mandatory to specify at least the name, the description,
+        # and the addressOffset
+        self.derived_from = derived_from
+        self.name = name
+        self.description = description
+        self.address_offset = address_offset
+        self.dim = dim
+        self.dim_indices = dim_indices
+        self.dim_increment = dim_increment
+
+        self._alternate_cluster = alternate_cluster
+        self._header_struct_name = header_struct_name
+        self._size = size
+        self._access = access
+        self._protection = protection
+        self._reset_value = reset_value
+        self._reset_mask = reset_mask
+        self._register = register
+        self._cluster = cluster
+
+        # make parent association
+        for register in self._register:
+            register.parent = self
+        for cluster in self._cluster:
+            cluster.parent = self
+
+    def __getattr__(self, attr):
+        return self._lookup_possibly_derived_attribute(attr)
+
+    def updated_register(self, reg, clu, i):
+        new_reg = SVDRegister(
+            name="{}_{}".format(clu.name % i, reg.name),
+            fields=reg.fields,
+            derived_from=reg.derived_from,
+            description=reg.description,
+            address_offset=clu.address_offset + reg.address_offset + i*clu.dim_increment,
+            size=reg.size,
+            access=reg.access,
+            protection=reg.protection,
+            reset_value=reg.reset_value,
+            reset_mask=reg.reset_mask,
+            display_name=reg.display_name,
+            alternate_group=reg.alternate_group,
+            modified_write_values=reg.modified_write_values,
+            read_action=reg.read_action,
+        )
+        new_reg.parent = self
+        return new_reg
+
+    @property
+    def registers(self):
+        for i in six.moves.range(self.dim):
+            for reg in self._register:
+                yield self.updated_register(reg, self, i)
+            for cluster in self._cluster:
+                for reg in cluster.registers:
+                    yield self.updated_register(reg, cluster, i)
+
+    def get_derived_from(self):
+        # TODO: add support for dot notation derivedFrom
+        if self.derived_from is None:
+            return None
+
+        for register in self.parent.registers:
+            if register.name == self.derived_from:
+                return register
+
+        raise KeyError("Unable to find derived_from: %r" % self.derived_from)
+
+    def is_reserved(self):
+        return 'reserved' in self.name.lower()
+
+
 class SVDAddressBlock(SVDElement):
     def __init__(self, offset, size, usage):
         SVDElement.__init__(self)
@@ -298,9 +457,12 @@ def __init__(self, name, value):
 
 
 class SVDPeripheral(SVDElement):
-    def __init__(self, name, version, derived_from, description, prepend_to_name, base_address, address_block,
-                 interrupts, registers, register_arrays, size, access, protection, reset_value, reset_mask,
-                 group_name, append_to_name, disable_condition):
+    def __init__(self, name, version, derived_from, description,
+                 prepend_to_name, base_address, address_block,
+                 interrupts, registers, register_arrays, size, access,
+                 protection, reset_value, reset_mask,
+                 group_name, append_to_name, disable_condition,
+                 clusters):
         SVDElement.__init__(self)
 
         # items with underscore are potentially derived
@@ -322,6 +484,7 @@ def __init__(self, name, version, derived_from, description, prepend_to_name, ba
         self._group_name = group_name
         self._append_to_name = append_to_name
         self._disable_condition = disable_condition
+        self._clusters = clusters
 
         # make parent association for complex node types
         for i in _none_as_empty(self._interrupts):
@@ -339,6 +502,8 @@ def registers(self):
             regs.append(reg)
         for arr in self._lookup_possibly_derived_attribute('register_arrays'):
             regs.extend(arr.registers)
+        for cluster in self._lookup_possibly_derived_attribute('clusters'):
+            regs.extend(cluster.registers)
         return regs
 
     def get_derived_from(self):

python/cmsis_svd/parser.py

@@ -17,11 +17,12 @@
 
 import six
 
-from cmsis_svd.model import SVDDevice, SVDRegisterArray
+from cmsis_svd.model import SVDDevice
 from cmsis_svd.model import SVDPeripheral
 from cmsis_svd.model import SVDInterrupt
 from cmsis_svd.model import SVDAddressBlock
-from cmsis_svd.model import SVDRegister
+from cmsis_svd.model import SVDRegister, SVDRegisterArray
+from cmsis_svd.model import SVDRegisterCluster, SVDRegisterClusterArray
 from cmsis_svd.model import SVDField
 from cmsis_svd.model import SVDEnumeratedValue
 from cmsis_svd.model import SVDCpu
@@ -224,6 +225,76 @@ def _parse_registers(self, register_node):
                 dim_increment=dim_increment,
             )
 
+    def _parse_cluster(self, cluster_node):
+        dim = _get_int(cluster_node, 'dim')
+        name = _get_text(cluster_node, 'name')
+        derived_from = _get_text(cluster_node, 'derivedFrom')
+        description = _get_text(cluster_node, 'description')
+        address_offset = _get_int(cluster_node, 'addressOffset')
+        size = _get_int(cluster_node, 'size')
+        access = _get_text(cluster_node, 'access')
+        protection = _get_text(cluster_node, 'protection')
+        reset_value = _get_int(cluster_node, 'resetValue')
+        reset_mask = _get_int(cluster_node, 'resetMask')
+        dim_increment = _get_int(cluster_node, 'dimIncrement')
+        dim_index_text = _get_text(cluster_node, 'dimIndex')
+        alternate_cluster = _get_text(cluster_node, 'alternateGluster')
+        header_struct_name = _get_text(cluster_node, 'headerStructName')
+        cluster = []
+        for sub_cluster_node in cluster_node.findall("./cluster"):
+            cluster.append(self._parse_cluster(sub_cluster_node))
+        register = []
+        for reg_node in cluster_node.findall("./register"):
+            register.append(self._parse_registers(reg_node))
+
+        if dim is None:
+            return SVDRegisterCluster(
+                name=name,
+                derived_from=derived_from,
+                description=description,
+                address_offset=address_offset,
+                size=size,
+                access=access,
+                protection=protection,
+                reset_value=reset_value,
+                reset_mask=reset_mask,
+                alternate_cluster=alternate_cluster,
+                header_struct_name=header_struct_name,
+                register=register,
+                cluster=cluster,
+            )
+        else:
+            # the node represents a register array
+            if dim_index_text is None:
+                dim_indices = range(0, dim)  # some files omit dimIndex
+            elif ',' in dim_index_text:
+                dim_indices = dim_index_text.split(',')
+            elif '-' in dim_index_text:  # some files use <dimIndex>0-3</dimIndex> as an inclusive inclusive range
+                m = re.search(r'([0-9]+)-([0-9]+)', dim_index_text)
+                dim_indices = range(int(m.group(1)), int(m.group(2)) + 1)
+            else:
+                raise ValueError("Unexpected dim_index_text: %r" % dim_index_text)
+
+            # yield `SVDRegisterArray` (caller will differentiate on type)
+            return SVDRegisterClusterArray(
+                name=name,
+                derived_from=derived_from,
+                description=description,
+                address_offset=address_offset,
+                size=size,
+                access=access,
+                protection=protection,
+                reset_value=reset_value,
+                reset_mask=reset_mask,
+                alternate_cluster=alternate_cluster,
+                header_struct_name=header_struct_name,
+                register=register,
+                cluster=cluster,
+                dim=dim,
+                dim_increment=dim_increment,
+                dim_indices=dim_indices,
+            )
+
     def _parse_address_block(self, address_block_node):
         return SVDAddressBlock(
             _get_int(address_block_node, 'offset'),
@@ -248,6 +319,11 @@ def _parse_peripheral(self, peripheral_node):
             else:
                 registers.append(reg)
 
+        clusters = []
+        for cluster_node in peripheral_node.findall('./registers/cluster'):
+            reg = self._parse_cluster(cluster_node)
+            clusters.append(reg)
+
         # parse all interrupts for the peripheral
         interrupts = []
         for interrupt_node in peripheral_node.findall('./interrupt'):
@@ -311,6 +387,11 @@ def _parse_peripheral(self, peripheral_node):
             register_arrays=register_arrays,
             registers=registers,
 
+            # <cluster>
+            #    ...
+            # </cluster>
+            clusters=clusters,
+
             # (not mentioned in docs -- applies to all registers)
             protection=_get_text(peripheral_node, 'protection'),
         )