peakrdl-python 3.1.0rc1__tar.gz → 3.1.0rc2__tar.gz

{peakrdl_python-3.1.0rc1 → peakrdl_python-3.1.0rc2}/.github/workflows/action.yaml

@@ -161,7 +161,8 @@ jobs:
           sleep 10
           python -m generate_and_test --RDL_source_file tests/testcases/user_defined_properties.rdl --root_node user_defined_properties --udp bool_property_to_include enum_property_to_include int_property_to_include str_property_to_include struct_property_to_include double_layer_struct_property_to_include
           sleep 10
-          
+          python -m generate_and_test --RDL_source_file tests/testcases/user_defined_properties.rdl --root_node user_defined_properties --udp bool_property_to_include enum_property_to_include int_property_to_include str_property_to_include struct_property_to_include double_layer_struct_property_to_include int_array_property_to_include str_array_property_to_include enum_array_property_to_include
+          sleep 10
           python -m generate_and_test --RDL_source_file tests/testcases/user_defined_properties.rdl --root_node user_defined_properties --udp_regex "bool_property_to_include|enum_property_to_include|int_property_to_include|str_property_to_include|struct_property_to_include|double_layer_struct_property_to_include"
           sleep 10
 

{peakrdl_python-3.1.0rc1 → peakrdl_python-3.1.0rc2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: peakrdl-python
-Version: 3.1.0rc1
+Version: 3.1.0rc2
 Summary: Generate Python Register Access Layer (RAL) from SystemRDL
 Author: Keith Brady
 License:              GNU LESSER GENERAL PUBLIC LICENSE

{peakrdl_python-3.1.0rc1 → peakrdl_python-3.1.0rc2}/src/peakrdl_python/__about__.py

@@ -17,4 +17,4 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 Variables that describes the peakrdl-python Package
 """
-__version__ = "3.1.0rc1"
+__version__ = "3.1.0rc2"

{peakrdl_python-3.1.0rc1 → peakrdl_python-3.1.0rc2}/src/peakrdl_python/exporter.py

@@ -243,6 +243,7 @@ class PythonExporter:
             'asyncoutput': asyncoutput,
             'isinstance': isinstance,
             'str': str,
+            'list': list,
             'uses_enum': uses_enum(top_block),
             'get_fully_qualified_type_name': partial(
                 unique_component_walker.python_class_name,
@@ -414,14 +415,18 @@ class PythonExporter:
 
                 context = {
                     'top_node': top_block,
-                    'systemrdlRegNode': RegNode,
                     'systemrdlFieldNode': FieldNode,
+                    'systemrdlRegNode': RegNode,
+                    'systemrdlRegfileNode': RegfileNode,
+                    'systemrdlAddrmapNode': AddrmapNode,
+                    'systemrdlMemNode': MemNode,
                     'systemrdlSignalNode': SignalNode,
                     'systemrdlUserStruct': UserStruct,
                     'systemrdlUserEnum': UserEnum,
                     'isinstance': isinstance,
                     'type': type,
                     'str': str,
+                    'list': list,
                     'asyncoutput': asyncoutput,
                     'unique_registers': unique_register_subset,
                     'unique_property_enums':
@@ -511,14 +516,18 @@ class PythonExporter:
 
                 context = {
                     'top_node': top_block,
-                    'systemrdlMemNode': MemNode,
                     'systemrdlFieldNode': FieldNode,
+                    'systemrdlRegNode': RegNode,
+                    'systemrdlRegfileNode': RegfileNode,
+                    'systemrdlAddrmapNode': AddrmapNode,
+                    'systemrdlMemNode': MemNode,
                     'systemrdlSignalNode': SignalNode,
                     'systemrdlUserStruct': UserStruct,
                     'systemrdlUserEnum': UserEnum,
                     'isinstance': isinstance,
                     'type': type,
                     'str': str,
+                    'list' : list,
                     'asyncoutput': asyncoutput,
                     'unique_memories': unique_memory_subset,
                     'unique_property_enums':
@@ -584,11 +593,16 @@ class PythonExporter:
                 context = {
                     'top_node': top_block,
                     'systemrdlFieldNode': FieldNode,
+                    'systemrdlRegNode': RegNode,
+                    'systemrdlRegfileNode': RegfileNode,
+                    'systemrdlAddrmapNode': AddrmapNode,
+                    'systemrdlMemNode': MemNode,
                     'systemrdlUserStruct': UserStruct,
                     'systemrdlUserEnum': UserEnum,
                     'isinstance': isinstance,
                     'type': type,
                     'str': str,
+                    'list': list,
                     'asyncoutput': asyncoutput,
                     'unique_fields': unique_fields_subset,
                     'unique_property_enums':
@@ -845,6 +859,7 @@ class PythonExporter:
                 'isinstance': isinstance,
                 'type': type,
                 'str': str,
+                'list': list,
                 'full_slice_accessor': full_slice_accessor,
                 'get_python_path_segments': get_python_path_segments,
                 'safe_node_name': safe_node_name,
@@ -1167,7 +1182,7 @@ class PythonExporter:
         """
         enum_needed: list[UserEnumMeta] = []
 
-        def walk_property_struct_node(value: Any) -> None:
+        def walk_property_subnode(value: Any) -> None:
             if isinstance(value, UserEnum) and type(value) not in enum_needed:
                 enum_type = type(value)
                 if not isinstance(enum_type, UserEnumMeta):
@@ -1176,19 +1191,15 @@ class PythonExporter:
 
             if isinstance(value, UserStruct):
                 for sub_value in value.members.values():
-                    walk_property_struct_node(sub_value)
+                    walk_property_subnode(sub_value)
+
+            if isinstance(value, list):
+                for sub_value in value:
+                    walk_property_subnode(sub_value)
 
         for node in unique_components.nodes.values():
             for node_property_name in node.properties_to_include:
                 node_property = node.instance.get_property(node_property_name)
-                if isinstance(node_property, UserEnum) and type(node_property) not in enum_needed:
-                    enum_type = type(node_property)
-                    if not isinstance(enum_type, UserEnumMeta):
-                        raise TypeError(f'enum type should be UserEnumMeta, got {type(enum_type)}')
-                    enum_needed.append(enum_type)
-
-                if isinstance(node_property, UserStruct):
-                    for sub_value in node_property.members.values():
-                        walk_property_struct_node(sub_value)
+                walk_property_subnode(node_property)
 
         return enum_needed

{peakrdl_python-3.1.0rc1 → peakrdl_python-3.1.0rc2}/src/peakrdl_python/systemrdl_node_hashes.py

@@ -143,7 +143,7 @@ def __node_hash_components(node: Node,
                            udp_include_func: ShowUDPCallback,
                            include_name_and_desc: bool = True) -> list[Any]:
 
-    value_to_hash = []
+    value_to_hash:list[Any] = []
 
     if isinstance(node, FieldNode):
         value_to_hash.append('Field')
@@ -167,13 +167,18 @@ def __node_hash_components(node: Node,
         if desc is not None:
             value_to_hash.append(desc)
 
+    def udp_replace_for_hashing(item: Any) -> None:
+        if isinstance(item, list):
+            for child_udp_value in item:
+                udp_replace_for_hashing(child_udp_value)
+        elif isinstance(item, Node):
+            value_to_hash.append('.'.join(item.get_path_segments()))
+        else:
+            value_to_hash.append(item)
+
     for udp in get_properties_to_include(node, udp_include_func):
         udp_value = node.get_property(udp)
-        # systemRDL supports UDPs that cross-reference other parts of the register model
-        if isinstance(udp_value, Node):
-            value_to_hash.append('.'.join(udp_value.get_path_segments()))
-        else:
-            value_to_hash.append(node.get_property(udp))
+        udp_replace_for_hashing(udp_value)
 
     return value_to_hash
 

{peakrdl_python-3.1.0rc1 → peakrdl_python-3.1.0rc2}/src/peakrdl_python/templates/addrmap_tb.py.jinja

@@ -79,6 +79,7 @@ from ._{{top_node.inst_name}}_test_base import __name__ as base_name
 from ._{{top_node.inst_name}}_test_base import random_enum_reg_value
 
 {% from 'addrmap_udp_property.py.jinja' import udp_property_dict_entry with context %}
+{% from 'addrmap_udp_property.py.jinja' import udp_property_entry with context %}
 
 class {{fq_block_name}}_single_access({{top_node.inst_name}}_TestCase): # type: ignore[valid-type,misc]
 
@@ -96,18 +97,10 @@ class {{fq_block_name}}_single_access({{top_node.inst_name}}_TestCase): # type:
             {% else %}
                 {% for property_name in property_list %}
                 {% set property_value = node.get_property(property_name) %}
-                    {% if isinstance(property_value, systemrdlUserStruct) %}
-            self.assertDictEqual(self.dut.{{'.'.join(get_python_path_segments(node))}}.udp['{{property_name}}'], {    # type: ignore[arg-type]
-            {% for sub_name, sub_value in property_value.members.items() %} {{udp_property_dict_entry(sub_name, sub_value)}} {% endfor %}
-                } )
-                    {% elif isinstance(property_value, systemrdlUserEnum) %}
-            self.assertEqual(self.dut.{{'.'.join(get_python_path_segments(node))}}.udp['{{property_name}}'], {{ type(property_value).type_name }}_property_enumcls.{{ property_value.name.upper() }} )
-                    {% elif isinstance(property_value, str) %}
-            self.assertEqual(self.dut.{{'.'.join(get_python_path_segments(node))}}.udp['{{property_name}}'], "{{ property_value }}" )
-                    {% elif isinstance(property_value, systemrdlFieldNode) %}
-            self.assertEqual(self.dut.{{'.'.join(get_python_path_segments(node))}}.udp['{{property_name}}'],  self.dut.{{'.'.join(get_python_path_segments(property_value))}} )
+                    {% if isinstance(property_value, list) %}
+            self.assertEqual(self.dut.{{'.'.join(get_python_path_segments(node))}}.udp['{{property_name}}'], [{% for sub_property_value in property_value %}{{ udp_property_entry(sub_property_value, true) }},{% endfor %}] )
                     {% else %}
-            self.assertEqual(self.dut.{{'.'.join(get_python_path_segments(node))}}.udp['{{property_name}}'], {{ property_value }} )
+            self.assertEqual(self.dut.{{'.'.join(get_python_path_segments(node))}}.udp['{{property_name}}'], {{ udp_property_entry(property_value, true) }} )
                     {% endif %}
                 {% endfor %}
             {% endif %}

peakrdl_python-3.1.0rc2/src/peakrdl_python/templates/addrmap_udp_property.py.jinja

@@ -0,0 +1,62 @@
+{#
+peakrdl-python is a tool to generate Python Register Access Layer (RAL) from SystemRDL
+Copyright (C) 2021 - 2025
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as
+published by the Free Software Foundation, either version 3 of
+the License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#}
+
+{%- macro udp_property_entry(value, full_qual_resolution) %}
+    {%- if isinstance(value, systemrdlUserStruct) -%}
+    {
+        {%- for sub_name, sub_value in value.members.items() %}
+        {{udp_property_dict_entry(sub_name, sub_value, full_qual_resolution)|indent(4)}}
+        {%- endfor %}
+    }
+    {%- elif isinstance(value, systemrdlUserEnum) -%}
+    {{ type(value).type_name + '_property_enumcls.' + value.name.upper() }}
+    {%- elif isinstance(value, str) -%}
+    "{{ value }}"
+    {%- elif isinstance(value, (systemrdlFieldNode, systemrdlRegNode, systemrdlRegfileNode, systemrdlAddrmapNode, systemrdlMemNode)) -%}
+        {%- if full_qual_resolution -%}
+    self.dut.{{'.'.join(get_python_path_segments(value))}}
+        {%- else -%}
+    self._traverse_from_fully_qualified_name({{ value.get_path_segments() }})
+        {%- endif -%}
+    {%- else -%}
+    {{ value }}
+    {%- endif -%}
+{%- endmacro %}
+
+{%- macro udp_property_dict_entry(name, value, full_qual_resolution) %}
+    {%- if isinstance(value, list) -%}
+    '{{name}}' : [ {% for sub_value in value %}{{udp_property_entry(sub_value, full_qual_resolution)}}, {% endfor %}],
+    {%- else -%}
+    '{{name}}' : {{ udp_property_entry(value, full_qual_resolution) }},
+    {%- endif %}
+{% endmacro %}
+
+{%- macro udp_property(node) %}
+
+    {% set property_list = node.properties_to_include %}
+    {% if property_list %}
+    @property
+    def udp(self) -> UDPStruct:
+        return {
+            {% for property_name in property_list -%}
+            {{udp_property_dict_entry(property_name, node.instance.get_property(property_name), false)|indent(4)}}
+            {%- endfor %}
+               }
+
+    {% endif %}
+{%- endmacro %}

{peakrdl_python-3.1.0rc1 → peakrdl_python-3.1.0rc2}/src/peakrdl_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: peakrdl-python
-Version: 3.1.0rc1
+Version: 3.1.0rc2
 Summary: Generate Python Register Access Layer (RAL) from SystemRDL
 Author: Keith Brady
 License:              GNU LESSER GENERAL PUBLIC LICENSE

peakrdl_python-3.1.0rc2/tests/testcases/udp_with_referencing.rdl

@@ -0,0 +1,99 @@
+/*
+Testcase the #292 bug
+with a UDP that cross-references another
+*/
+property field_pointer {
+    type = field;
+    component = field;
+};
+
+property register_pointer {
+    type = reg;
+    component = reg;
+};
+
+property register_file_pointer {
+    type = regfile;
+    component = regfile;
+};
+
+property field_parent_pointer {
+    type = reg;
+    component = field;
+};
+
+property register_child_pointer {
+    type = field[];
+    component = reg;
+};
+
+struct addrmap_child {
+    regfile regfile_children[];
+    reg reg_children[];
+    mem mem_children[];
+    addrmap addrmap_children[];
+};
+
+property addrmap_child_pointer {
+    type = addrmap_child;
+    component = addrmap;
+};
+
+struct regfile_child {
+    regfile regfile_children[];
+    reg reg_children[];
+};
+
+property regfile_child_pointer {
+    type = regfile_child;
+    component = regfile;
+};
+
+addrmap udp_with_referencing {
+
+    reg reg_def {
+        field { fieldwidth=4; } field_a;
+        field { fieldwidth=4; } field_b;
+        field { fieldwidth=4; } field_c;
+        field { fieldwidth=4; } field_d;
+        register_child_pointer = '{ field_a, field_b, field_c, field_d } ;
+    };
+
+    regfile regfile_def {
+        regfile inner_regfile_def {
+            reg_def reg_value;
+            regfile_child_pointer = regfile_child'{ reg_children:'{ reg_value } };
+        };
+        reg_def reg_value;
+        inner_regfile_def inner_regfile_value;
+        regfile_child_pointer = regfile_child'{ reg_children:'{ reg_value }, regfile_children:'{ inner_regfile_value } };
+    };
+
+    mem mem_def {
+        mementries = 32;
+        memwidth = 32;
+
+        reg_def reg_value;
+    };
+
+    addrmap addrmap_def {
+        addrmap inner_addrmap_def {
+            reg_def reg_value;
+            regfile_def regfile_value;
+            addrmap_child_pointer = addrmap_child'{ reg_children:'{ reg_value }, regfile_children:'{ regfile_value } };
+        };
+        reg_def reg_value;
+        regfile_def regfile_value;
+        external mem_def mem_value;
+        inner_addrmap_def addrmap_value;
+        addrmap_child_pointer = addrmap_child'{ reg_children:'{ reg_value }, regfile_children:'{ regfile_value }, addrmap_children:'{ addrmap_value }, mem_children:'{ mem_value } };
+    };
+
+    addrmap_def main;
+    addrmap_def view;
+
+    view.reg_value.field_a->field_pointer = main.reg_value.field_a;
+    view.reg_value.field_a->field_parent_pointer = main.reg_value;
+
+    view.reg_value->register_pointer = main.reg_value;
+};

{peakrdl_python-3.1.0rc1 → peakrdl_python-3.1.0rc2}/tests/testcases/user_defined_properties.rdl

@@ -7,6 +7,7 @@ enum property_enum {
 
 enum inner_property_enum {
 			value0 = 0 { name = "Value 1"; };
+			value10 = 1 { name = "Value 10"; };
 		};
 
 struct property_struct {
@@ -18,6 +19,7 @@ struct property_struct {
 
 struct property_outer_struct {
     boolean a_bool;
+    longint unsigned num_array[];
     property_struct inner_struct;
 };
 
@@ -29,6 +31,10 @@ property enum_property_to_include { type = property_enum; component = addrmap |
 property int_property_to_include { type = number; component = addrmap | regfile | reg | field | mem; };
 property str_property_to_include { type = string; component = addrmap | regfile | reg | field | mem; };
 property int_property_to_exclude { type = number; component = addrmap | regfile | reg | field | mem; };
+property int_array_property_to_include { component = addrmap | regfile | reg | field | mem; type = longint unsigned[] ; } ;
+property str_array_property_to_include { component = addrmap | regfile | reg | field | mem; type = string[] ; } ;
+property enum_array_property_to_include { type = property_enum[]; component = addrmap | regfile | reg | field | mem; };
+property struct_array_property_to_include { type = property_struct[]; component = addrmap | regfile | reg | field | mem; };
 
 addrmap user_defined_properties {
 
@@ -40,9 +46,14 @@ addrmap user_defined_properties {
         enum_property_to_include = property_enum::value1;
         str_property_to_include = "invalid";
         struct_property_to_include = property_struct'{a_bool:true, a_string:"hello", a_number:10, a_enum:inner_property_enum::value0};
-        double_layer_struct_property_to_include = property_outer_struct'{a_bool:true, inner_struct:property_struct'{a_bool:true, a_string:"inner", a_number:11, a_enum:inner_property_enum::value0} };
+        double_layer_struct_property_to_include = property_outer_struct'{a_bool:true, num_array:'{ 1, 2, 3 } ,inner_struct:property_struct'{a_bool:true, a_string:"inner", a_number:11, a_enum:inner_property_enum::value0} };
         int_property_to_include = 10;
         int_property_to_exclude = 15;
+        int_array_property_to_include = '{ 2, 34, 73 } ;
+        str_array_property_to_include = '{ "foo", "bar" } ;
+        enum_array_property_to_include = '{ property_enum::value1, property_enum::value2 };
+        struct_array_property_to_include = '{ property_struct'{a_bool:true,  a_string:"hello",   a_number:10, a_enum:inner_property_enum::value0},
+                                              property_struct'{a_bool:false, a_string:"goodbye", a_number:11, a_enum:inner_property_enum::value10} };
     };
 
     reg register_with_properties {
@@ -60,6 +71,7 @@ addrmap user_defined_properties {
     register_with_properties reg_b[3];
     reg_b->str_property_to_include = "user_defined_properties.reg_b";
     reg_b.field_a->str_property_to_include = "user_defined_properties.reg_b.field_a";
+    reg_b->int_array_property_to_include = '{ 3, 67, 84, 101 };
 
     regfile regfile_with_properties {
         bool_property_to_include = true;
@@ -78,6 +90,7 @@ addrmap user_defined_properties {
     reg_file_a.reg_a.field_a->str_property_to_include = "user_defined_properties.reg_file_a.reg_a.field_a";
     reg_file_a.reg_b->str_property_to_include = "user_defined_properties.reg_file_a.reg_b";
     reg_file_a.reg_b.field_a->str_property_to_include = "user_defined_properties.reg_file_a.reg_b.field_a";
+    reg_file_a->int_array_property_to_include = '{ 3, 67, 84, 101 };
 
     regfile_with_properties reg_file_b[2];
 
@@ -86,6 +99,7 @@ addrmap user_defined_properties {
     reg_file_b.reg_a.field_a->str_property_to_include = "user_defined_properties.reg_file_b.reg_a.field_a";
     reg_file_b.reg_b->str_property_to_include = "user_defined_properties.reg_file_b.reg_b";
     reg_file_b.reg_b.field_a->str_property_to_include = "user_defined_properties.reg_file_b.reg_b.field_a";
+    reg_file_b->int_array_property_to_include = '{ 5, 68, 102, 103, 104 };
 
     external mem {
         mementries = 10;
@@ -96,6 +110,9 @@ addrmap user_defined_properties {
         struct_property_to_include = property_struct'{a_bool:true, a_string:"hello", a_number:10, a_enum:inner_property_enum::value0};
         int_property_to_include = 10;
         int_property_to_exclude = 15;
+        int_array_property_to_include = '{ 2, 34, 73 } ;
+        str_array_property_to_include = '{ "foo", "bar" } ;
+        enum_array_property_to_include = '{ property_enum::value1, property_enum::value2 };
     } mem_with_properties;
 
     external mem {
@@ -134,6 +151,10 @@ addrmap user_defined_properties {
         regfile_with_properties reg_file_b[2];
         register_with_properties reg_a;
         register_with_properties reg_b[3];
+        int_array_property_to_include = '{ 5, 36, 77 } ;
+        str_array_property_to_include = '{ "foo_me", "bar_me" } ;
+        enum_array_property_to_include = '{ property_enum::value2, property_enum::value3 };
+
     };
 
     addr_with_properties addrmap_a;

{peakrdl_python-3.1.0rc1 → peakrdl_python-3.1.0rc2}/tests/unit_tests/test_export.py

@@ -256,7 +256,10 @@ class TestExportUDP(unittest.TestCase):
                               'struct_property_to_include',
                               'enum_property_to_include',
                               'int_property_to_include',
-                              'str_property_to_include']
+                              'str_property_to_include',
+                              'int_array_property_to_include',
+                              'str_array_property_to_include',
+                              'enum_array_property_to_include']
         def check_udp_present(dut, udp_to_include:list[str]) -> None:
             for udp in full_property_list:
                 if udp in udp_to_include:

peakrdl_python-3.1.0rc1/src/peakrdl_python/templates/addrmap_udp_property.py.jinja

@@ -1,50 +0,0 @@
-{#
-peakrdl-python is a tool to generate Python Register Access Layer (RAL) from SystemRDL
-Copyright (C) 2021 - 2025
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU Lesser General Public License as
-published by the Free Software Foundation, either version 3 of
-the License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License
-along with this program.  If not, see <https://www.gnu.org/licenses/>.
-#}
-
-{%- macro udp_property_dict_entry(name, value) %}
-    {% if isinstance(value, systemrdlUserStruct) %}
-    '{{name}}' : {
-        {% for sub_name, sub_value in value.members.items() %}
-        {{udp_property_dict_entry(sub_name, sub_value)|indent(4)}}
-        {% endfor %}
-                },
-    {% elif isinstance(value, systemrdlUserEnum) %}
-    '{{name}}' : {{ type(value).type_name + '_property_enumcls.' + value.name.upper() }} ,
-    {% elif isinstance(value, str) %}
-    '{{name}}' : "{{ value }}" ,
-    {% elif isinstance(value, systemrdlFieldNode) %}
-    '{{name}}' : self._traverse_from_fully_qualified_name({{ value.get_path_segments() }}) ,
-    {% else %}
-    '{{name}}' : {{ value }} ,
-    {% endif %}
-{% endmacro %}
-
-{%- macro udp_property(node) %}
-
-    {% set property_list = node.properties_to_include %}
-    {% if property_list %}
-    @property
-    def udp(self) -> UDPStruct:
-        return {
-            {% for property_name in property_list %}
-            {{udp_property_dict_entry(property_name, node.instance.get_property(property_name))}}
-            {% endfor %}
-               }
-
-    {% endif %}
-{%- endmacro %}

peakrdl_python-3.1.0rc1/tests/testcases/udp_with_referencing.rdl

@@ -1,31 +0,0 @@
-/*
-Testcase the #292 bug
-with a UDP that cross-references another
-*/
-property field_pointer {
-    type = field;
-    component = field;
-};
-
-property register_pointer {
-    type = reg;
-    component = reg;
-};
-
-addrmap udp_with_referencing {
-    reg {
-        field {
-            hw = rw;
-            sw = rw;
-        } value;
-    } view;
-
-    reg {
-        field {
-            hw = rw;
-            sw = rw;
-        } value;
-    } pointer;
-
-    view.value->field_pointer = pointer.value;
-};