def _parse_peripheral(self, peripheral_node):
registers = []
for register_node in peripheral_node.findall('./registers/register'):
reg = self._parse_register(register_node)
if reg.dim and self.expand_arrays_of_registers is 1:
for r in duplicate_array_of_registers(reg):
registers.append(r)
elif self.remove_reserved is 0 or 'reserved' not in reg.name.lower() :
registers.append(reg)
interrupts = []
for interrupt_node in peripheral_node.findall('./interrupt'):
interrupts.append(self._parse_interrupt(interrupt_node))
address_block_nodes = peripheral_node.findall('./addressBlock')
if address_block_nodes:
address_block = self._parse_address_block(address_block_nodes[0])
else:
address_block = None
return SVDPeripheral(
name=_get_text(peripheral_node, 'name'),
description=_get_text(peripheral_node, 'description'),
prepend_to_name=_get_text(peripheral_node, 'prependToName'),
base_address=_get_int(peripheral_node, 'baseAddress'),
address_block=address_block,
interrupts=interrupts,
registers=registers,
)
def _parse_peripheral(self, peripheral_node):
# parse registers
registers = None if peripheral_node.find('registers') is None else []
register_arrays = None if peripheral_node.find('registers') is None else []
for register_node in peripheral_node.findall('./registers/register'):
reg = self._parse_registers(register_node)
if isinstance(reg, SVDRegisterArray):
register_arrays.append(reg)
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'):
interrupts.append(self._parse_interrupt(interrupt_node))
interrupts = interrupts if interrupts else None
# parse address block if any
address_blocks = []
for address_block_node in peripheral_node.findall('./addressBlock'):
address_blocks.append(self._parse_address_block(address_block_node))
address_blocks = address_blocks if address_blocks else None
return SVDPeripheral(
# <name>identifierType</name>
# <version>xs:string</version>
# <description>xs:string</description>
name=_get_text(peripheral_node, 'name'),
version=_get_text(peripheral_node, 'version'),
derived_from=peripheral_node.get('derivedFrom'),
description=_get_text(peripheral_node, 'description'),
# <groupName>identifierType</groupName>
# <prependToName>identifierType</prependToName>
# <appendToName>identifierType</appendToName>
# <disableCondition>xs:string</disableCondition>
# <baseAddress>scaledNonNegativeInteger</baseAddress>
group_name=_get_text(peripheral_node, 'groupName'),
prepend_to_name=_get_text(peripheral_node, 'prependToName'),
append_to_name=_get_text(peripheral_node, 'appendToName'),
disable_condition=_get_text(peripheral_node, 'disableCondition'),
base_address=_get_int(peripheral_node, 'baseAddress'),
# <!-- registerPropertiesGroup -->
# <size>scaledNonNegativeInteger</size>
# <access>accessType</access>
# <resetValue>scaledNonNegativeInteger</resetValue>
# <resetMask>scaledNonNegativeInteger</resetMask>
size=_get_int(peripheral_node, "size"),
access=_get_text(peripheral_node, 'access'),
reset_value=_get_int(peripheral_node, "resetValue"),
reset_mask=_get_int(peripheral_node, "resetMask"),
# <addressBlock>
# <offset>scaledNonNegativeInteger</offset>
# <size>scaledNonNegativeInteger</size>
# <usage>usageType</usage>
# <protection>protectionStringType</protection>
# </addressBlock>
address_blocks=address_blocks,
# <interrupt>
# <name>identifierType</name>
# <value>scaledNonNegativeInteger</value>
# <description>xs:string</description>
# </interrupt>
interrupts=interrupts,
# <registers>
# ...
# </registers>
register_arrays=register_arrays,
registers=registers,
# <cluster>
# ...
# </cluster>
clusters=clusters,
# (not mentioned in docs -- applies to all registers)
protection=_get_text(peripheral_node, 'protection'),
)