Merge pull request #91 from krcb197/enum_test_cases

Enhanced Enum support

Author: krcb197

.github/workflows/action.yaml

@@ -77,7 +77,6 @@ jobs:
         python -m pip install --upgrade pip
         python -m pip install .
 
-        python -m pip install pytest
         python -m pip install mypy
 
 
@@ -89,7 +88,7 @@ jobs:
         mypy testcase_output --config-file=tests/.mypy.ini
         # pylint --rcfile tests/pylint.rc testcase_output/autopep8 --disable=duplicate-code,line-too-long,too-many-statements,invalid-name,unused-import,too-many-instance-attributes,too-many-arguments,too-many-lines
 
-        pytest testcase_output
+        python -m unittest discover -s testcase_output
 
     - name: Backward Compatibility Test
       run: |
@@ -101,11 +100,11 @@ jobs:
 
         peakrdl python tests/testcases/basic.rdl -o peakrdl_out/raw/
         peakrdl python tests/testcases/simple.xml tests/testcases/multifile.rdl -o peakrdl_out/raw
-        pytest peakrdl_out/raw
+        python -m unittest discover -s peakrdl_out/raw
         peakrdl python tests/testcases/basic.rdl -o peakrdl_out/autopep8/ --autoformat
-        pytest peakrdl_out/autopep8
+        python -m unittest discover -s peakrdl_out/autopep8
         peakrdl python tests/testcases/basic.rdl -o peakrdl_out/raw_async/ --async
-        pytest peakrdl_out/raw_async
+        python -m unittest discover -s peakrdl_out/raw_async
 
         peakrdl python tests/testcases/basic.rdl -o peakrdl_out/no_test/ --skip_test_case_generation
 

generate_testcases.py

@@ -24,6 +24,10 @@
     if testcase_name == 'multifile':
         # this needs the simple.xml file included
         root = pp.compile_rdl(rdl_file, ipxact_files=[os.path.join(test_case_path, 'simple.xml')])
+    elif testcase_name == 'multi_block':
+        # this needs the simple.xml file included
+        root = pp.compile_rdl(rdl_file, ipxact_files=[os.path.join(test_case_path, 'block_a.xml'),
+                                                      os.path.join(test_case_path, 'block_b.xml')])
     else:
         root = pp.compile_rdl(rdl_file)
 

src/peakrdl_python/__about__.py

@@ -1,4 +1,4 @@
 """
 Variables that describes the PeakRDL Python Package
 """
-__version__ = "0.4.1"
+__version__ = "0.4.2"

src/peakrdl_python/exporter.py

@@ -4,7 +4,7 @@
 import os
 from pathlib import Path
 from shutil import copyfile
-from typing import List, NoReturn
+from typing import List, NoReturn, Iterable, Tuple
 from glob import glob
 
 import autopep8 # type: ignore
@@ -13,15 +13,16 @@
 from systemrdl.node import RootNode, Node, RegNode, AddrmapNode, RegfileNode # type: ignore
 from systemrdl.node import FieldNode, MemNode, AddressableNode # type: ignore
 from systemrdl.node import SignalNode # type: ignore
-from systemrdl.rdltypes import OnReadType, OnWriteType, PropertyReference # type: ignore
+from systemrdl.rdltypes import OnReadType, OnWriteType, PropertyReference  # type: ignore
+from systemrdl.rdltypes.user_enum import UserEnumMeta  # type: ignore
 
 from .systemrdl_node_utility_functions import get_reg_readable_fields, get_reg_writable_fields, \
-    get_array_dim, get_table_block, get_dependent_enum, get_dependent_component, \
+    get_array_dim, get_table_block, get_dependent_component, \
     get_field_bitmask_hex_string, get_field_inv_bitmask_hex_string, \
     get_field_max_value_hex_string, get_reg_max_value_hex_string, get_fully_qualified_type_name, \
-    uses_enum, fully_qualified_enum_type, uses_memory, \
+    uses_enum, uses_memory, \
     get_memory_max_entry_value_hex_string, get_memory_width_bytes, \
-    get_field_default_value
+    get_field_default_value, get_enum_values
 
 from .lib import get_array_typecode
 
@@ -147,8 +148,9 @@ def export(self, node: Node, path: str,
                 'get_fully_qualified_type_name': self._lookup_type_name,
                 'get_array_dim': get_array_dim,
                 'get_dependent_component': get_dependent_component,
-                'get_dependent_enum': get_dependent_enum,
-                'get_fully_qualified_enum_type': fully_qualified_enum_type,
+                'get_dependent_enum': self._get_dependent_enum,
+                'get_enum_values': get_enum_values,
+                'get_fully_qualified_enum_type': self._fully_qualified_enum_type,
                 'get_field_bitmask_hex_string': get_field_bitmask_hex_string,
                 'get_field_inv_bitmask_hex_string': get_field_inv_bitmask_hex_string,
                 'get_field_max_value_hex_string': get_field_max_value_hex_string,
@@ -292,3 +294,57 @@ def _raise_template_error(self, message: str) -> NoReturn:
 
         """
         raise PythonExportTemplateError(message)
+
+    def _fully_qualified_enum_type(self,
+                                   field_enum: UserEnumMeta,
+                                   root_node: AddressableNode,
+                                   owning_field: FieldNode) -> str:
+        """
+        Returns the fully qualified class type name, for an enum
+        """
+        if not hasattr(field_enum, '_parent_scope'):
+            # this happens if the enum is has been declared in an IPXACT file
+            # which is imported
+            return self._lookup_type_name(owning_field) + '_' + field_enum.__name__
+
+        parent_scope = getattr(field_enum, '_parent_scope')
+
+        if parent_scope is None:
+            # this happens if the enum is has been declared in an IPXACT file
+            # which is imported
+            return self._lookup_type_name(owning_field) + '_' + field_enum.__name__
+
+        if root_node.inst.original_def == parent_scope:
+            return field_enum.__name__
+
+        dependent_components = get_dependent_component(root_node)
+
+        for component in dependent_components:
+            if component.inst.original_def == parent_scope:
+                return get_fully_qualified_type_name(component) + '_' + field_enum.__name__
+
+        raise RuntimeError('Failed to find parent node to reference')
+
+    def _get_dependent_enum(self, node: AddressableNode) -> \
+            Iterable[Tuple[UserEnumMeta, FieldNode]]:
+        """
+        iterable of enums which is used by a descendant of the input node,
+        this list is de-duplicated
+
+        :param node: node to analysis
+        :return: nodes that are dependent on the specified node
+        """
+        enum_needed = []
+        for child_node in node.descendants():
+            if isinstance(child_node, FieldNode):
+                if 'encode' in child_node.list_properties():
+                    # found an field with an enumeration
+
+                    field_enum = child_node.get_property('encode')
+                    fully_qualified_enum_name = self._fully_qualified_enum_type(field_enum,
+                                                                                node,
+                                                                                child_node)
+
+                    if fully_qualified_enum_name not in enum_needed:
+                        enum_needed.append(fully_qualified_enum_name)
+                        yield field_enum, child_node

src/peakrdl_python/lib/fields.py

@@ -796,6 +796,16 @@ def enum_cls(self) -> EnumMeta:
         The enumeration class for this field
         """
 
+    @property
+    def _enum_values(self) -> List[int]:
+        """
+        checks whether the default value is within the legal range for the enum
+
+        Returns:
+
+        """
+        return [e.value for e in self.enum_cls] # type: ignore[var-annotated]
+
 
 class FieldEnumReadWrite(FieldReadWrite, FieldEnum, ABC):
     """

src/peakrdl_python/systemrdl_node_utility_functions.py

@@ -2,15 +2,15 @@
 A set of utility functions that perform supplementary processing on a node in a compiled
 system RDL dataset.
 """
-from typing import Iterable, Optional
+from typing import Iterable, Optional, List
 
 import textwrap
 
 from systemrdl.node import Node, RegNode  # type: ignore
 from systemrdl.node import FieldNode, AddressableNode  # type: ignore
 from systemrdl.node import MemNode  # type: ignore
 from systemrdl.node import SignalNode  # type: ignore
-from systemrdl.rdltypes import UserEnum # type: ignore
+from systemrdl.rdltypes.user_enum import UserEnumMeta  # type: ignore
 
 def get_fully_qualified_type_name(node: Node) -> str:
     """
@@ -63,52 +63,6 @@ def get_dependent_component(node: AddressableNode) -> Iterable[Node]:
 
         yield child_node
 
-
-def get_dependent_enum(node: AddressableNode) -> Iterable[FieldNode]:
-    """
-    iterable of enums which is used by a descendant of the input node,
-    this list is de-duplicated
-
-    :param node: node to analysis
-    :return: nodes that are dependent on the specified node
-    """
-    enum_needed = []
-    for child_node in node.descendants():
-        if isinstance(child_node, FieldNode):
-            if 'encode' in child_node.list_properties():
-                # found an field with an enumeration
-
-                field_enum = child_node.get_property('encode')
-                fully_qualified_enum_name = fully_qualified_enum_type(field_enum, node)
-
-                if fully_qualified_enum_name not in enum_needed:
-                    enum_needed.append(fully_qualified_enum_name)
-                    yield field_enum
-
-
-def fully_qualified_enum_type(field_enum: UserEnum, root_node: AddressableNode) -> str:
-    """
-    Returns the fully qualified class type name, for an enum
-    """
-    if not hasattr(field_enum, '_parent_scope'):
-        # this happens if the enum is has been declared in an IPXACT file
-        # which is imported
-        return field_enum.__name__
-
-    parent_scope = getattr(field_enum, '_parent_scope')
-
-    if root_node.inst.original_def == parent_scope:
-        return field_enum.__name__
-
-    dependent_components = get_dependent_component(root_node)
-
-    for component in dependent_components:
-        if component.inst.original_def == parent_scope:
-            return get_fully_qualified_type_name(component) + '_' + field_enum.__name__
-
-    raise RuntimeError('Failed to find parent node to reference')
-
-
 def get_table_block(node: Node) -> str:
     """
     Converts the documentation for a systemRDL node into a nicely formated table that can be
@@ -358,13 +312,16 @@ def get_field_default_value(node: FieldNode) -> Optional[int]:
     None if the field is not reset or if the reset value is a signal that can be in an unknown
     state
     """
+    if not isinstance(node, FieldNode):
+        raise TypeError(f'node is not a {type(FieldNode)} got {type(node)}')
 
     value = node.get_property('reset')
 
     if value is None:
         return None
 
     if isinstance(value, int):
+
         return value
 
     if isinstance(value, (FieldNode, SignalNode)):
@@ -373,3 +330,18 @@ def get_field_default_value(node: FieldNode) -> Optional[int]:
         return None
 
     raise TypeError(f'unhandled type for field default type={type(value)}')
+
+
+def get_enum_values(enum: UserEnumMeta) -> List[int]:
+    """
+
+    Args:
+        enum: a field enum
+
+    Returns: A list of all the values for an enum
+
+    """
+    if not isinstance(enum, UserEnumMeta):
+        raise TypeError(f'node is not a {type(UserEnumMeta)} got {type(enum)}')
+
+    return [e.value for e in enum]

src/peakrdl_python/templates/addrmap.py.jinja

@@ -12,6 +12,7 @@ from typing import AsyncGenerator
 {% else %}
 from typing import Generator
 {% endif %}
+import warnings
 
 
 from contextlib import {% if asyncoutput %}async{% endif %}contextmanager
@@ -357,9 +358,9 @@ class {{get_fully_qualified_type_name(node)}}_array_cls(AddressMapArray):
 
 {% if uses_enum %}
 # root level enum definitions
-{%- for enum_needed in get_dependent_enum(top_node.parent) %}
+{%- for enum_needed, owning_field in get_dependent_enum(top_node.parent) %}
 @unique
-class {{get_fully_qualified_enum_type(enum_needed, top_node.parent)}}_enumcls(IntEnum):
+class {{get_fully_qualified_enum_type(enum_needed, top_node.parent, owning_field)}}_enumcls(IntEnum):
 
     {% for value_of_enum_needed in enum_needed -%}
     {{ value_of_enum_needed.name.upper() }} = {{ value_of_enum_needed.value }}  {%- if value_of_enum_needed.rdl_desc is not none -%}# {{ value_of_enum_needed.rdl_desc }} {%- endif %}

src/peakrdl_python/templates/addrmap_field.py.jinja

@@ -13,7 +13,7 @@ class {{get_fully_qualified_type_name(node)}}_cls(Field{%- if 'encode' in node.l
     """
 
     {%- if 'encode' in node.list_properties() %}
-    __enum_cls = {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent)}}_enumcls
+    __enum_cls = {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent, node)}}_enumcls
     {% endif %}
 
     __slots__ : List[str] = []
@@ -27,7 +27,7 @@ class {{get_fully_qualified_type_name(node)}}_cls(Field{%- if 'encode' in node.l
         return self.__enum_cls
 
         {% if node.is_sw_readable %}
-    def decode_read_value(self, value: int) -> {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent)}}_enumcls:
+    def decode_read_value(self, value: int) -> {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent, node)}}_enumcls:
         """
         extracts the field value from a register value, by applying the bit
         mask and shift needed and conversion to the enum associated with the
@@ -46,7 +46,7 @@ class {{get_fully_qualified_type_name(node)}}_cls(Field{%- if 'encode' in node.l
 
         return self.enum_cls(field_value)
 
-    {% if asyncoutput %}async {% endif %}def read(self) -> {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent)}}_enumcls:
+    {% if asyncoutput %}async {% endif %}def read(self) -> {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent, node)}}_enumcls:
         """
         read the register and then perform the necessary actions, to report the
         value as the enumeration including:
@@ -63,23 +63,23 @@ class {{get_fully_qualified_type_name(node)}}_cls(Field{%- if 'encode' in node.l
         {% endif %}
 
         {% if node.is_sw_writable %}
-    def encode_write_value(self, value: {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent)}}_enumcls) -> int: # type: ignore[override]
+    def encode_write_value(self, value: {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent, node)}}_enumcls) -> int: # type: ignore[override]
 
         if not isinstance(value, self.enum_cls):
-            raise TypeError('value must be an {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent)}}_enumcls but got %s' % type(value))
+            raise TypeError('value must be an {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent, node)}}_enumcls but got %s' % type(value))
 
         return super().encode_write_value(value.value)
 
-    {% if asyncoutput %}async {% endif %}def write(self, value : {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent)}}_enumcls) -> None: # type: ignore[override]
+    {% if asyncoutput %}async {% endif %}def write(self, value : {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent, node)}}_enumcls) -> None: # type: ignore[override]
 
         if not isinstance(value, self.enum_cls):
-            raise TypeError('value must be an {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent)}}_enumcls but got %s' % type(value))
+            raise TypeError('value must be an {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent, node)}}_enumcls but got %s' % type(value))
 
         {% if asyncoutput %}await {% endif %}super().write(value.value)
         {% endif %}
 
     @property
-    def default(self) -> Optional[{{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent)}}_enumcls]:
+    def default(self) -> Optional[{{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent, node)}}_enumcls]:
         """
         The default value of the field
 
@@ -90,7 +90,13 @@ class {{get_fully_qualified_type_name(node)}}_cls(Field{%- if 'encode' in node.l
         int_default = super().default
 
         if int_default is not None:
-            return {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent)}}_enumcls(int_default)
+            if int_default in self._enum_values:
+                return {{get_fully_qualified_enum_type(node.get_property('encode'), top_node.parent, node)}}_enumcls(int_default)
+            else:
+                msg = f'reset value {int_default:d} is not within the enumeration for the class'
+                self._logger.warn(msg)
+                warnings.warn(msg)
+                return None
 
         return None
     {% endif %}

src/peakrdl_python/templates/addrmap_register.py.jinja

@@ -130,7 +130,7 @@ class {{get_fully_qualified_type_name(node)}}_cls(Reg{% if asyncoutput %}Async{%
 
 
     {% else %}
-    {% if asyncoutput %}async {% endif %}def write_fields(self, {%- for child_node in node.fields() -%} {{safe_node_name(child_node)}} : {%- if 'encode' in child_node.list_properties() %}{{get_fully_qualified_enum_type(child_node.get_property('encode'), top_node.parent)}}_enumcls{% else %}int{% endif %}{%- if not loop.last -%},{%- endif -%}{%- endfor -%}) -> None: # type: ignore[override]
+    {% if asyncoutput %}async {% endif %}def write_fields(self, {%- for child_node in node.fields() -%} {{safe_node_name(child_node)}} : {%- if 'encode' in child_node.list_properties() %}{{get_fully_qualified_enum_type(child_node.get_property('encode'), top_node.parent, child_node)}}_enumcls{% else %}int{% endif %}{%- if not loop.last -%},{%- endif -%}{%- endfor -%}) -> None: # type: ignore[override]
         """
         Do a write to the register, updating all fields
         """