specware 1.3.6__tar.gz → 1.3.8__tar.gz

{specware-1.3.6 → specware-1.3.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specware
-Version: 1.3.6
+Version: 1.3.8
 Summary: Provides utilities to specify software.
 Keywords: certification,documentation,markdown,qualification,requirements-management,traceability
 Author: The specware Authors

{specware-1.3.6 → specware-1.3.8}/pyproject.toml

@@ -4,7 +4,7 @@
 
 [project]
 name = "specware"
-version = "1.3.6"
+version = "1.3.8"
 description = "Provides utilities to specify software."
 authors = [
     {name = "The specware Authors", email = "specthings@embedded-brains.de"}

{specware-1.3.6 → specware-1.3.8}/src/specware/cliview.py

@@ -60,6 +60,24 @@ _PARENT_ROLES = [
     "test-timeouts", "verification-provider"
 ]
 
+# The interface group membership and the interface placement are each defined
+# by a pair of link roles which relate the items in opposite directions.  The
+# view lists the items of a pair in the order of their UIDs, so the choice of
+# the role does not change the tree.
+_MEMBER_CHILD_ROLES = ["interface-ingroup", "interface-ingroup-hidden"]
+
+_VIEW_CHILD_ROLES = [
+    role for role in _CHILD_ROLES if role not in _MEMBER_CHILD_ROLES
+]
+
+_VIEW_PARENT_ROLES = [
+    role for role in _PARENT_ROLES if role != "interface-group-member"
+]
+
+
+def _sorted_links(links: Iterable[Link]) -> list[Link]:
+    return sorted(links, key=lambda link: link.item.uid)
+
 
 def _get_value_dummy(_ctx: ItemGetValueContext) -> Any:
     return ""
@@ -122,8 +140,11 @@ def _visit_item(item: Item, mapper: ItemMapper, level: int,
 
 def _view_interface_placment(item: Item, mapper: ItemMapper, level: int,
                              validated_filter: str) -> None:
-    for link in itertools.chain(item.links_to_children("interface-placement"),
-                                item.links_to_parents("register-block-host")):
+    for link in _sorted_links(
+            itertools.chain(
+                item.links_to_children("interface-placement"),
+                item.links_to_parents(
+                    ["interface-host", "register-block-host"]))):
         if _visit_item(link.item, mapper, level, link, validated_filter):
             _view_interface_placment(link.item, mapper, level + 1,
                                      validated_filter)
@@ -146,9 +167,13 @@ def _view(item: Item, mapper: ItemMapper, level: int, link: Optional[Link],
     for link_2 in item.links_to_parents("reference"):
         _visit_item(link_2.item, mapper, level + 1, link_2, validated_filter)
     _view_interface_placment(item, mapper, level + 1, validated_filter)
-    for link_2 in item.links_to_children(_CHILD_ROLES):
-        _view(link_2.item, mapper, level + 1, link_2, validated_filter)
-    for link_2 in item.links_to_parents(_PARENT_ROLES):
+    for link_2 in itertools.chain(
+            item.links_to_children(_VIEW_CHILD_ROLES),
+            _sorted_links(
+                itertools.chain(
+                    item.links_to_children(_MEMBER_CHILD_ROLES),
+                    item.links_to_parents("interface-group-member"))),
+            item.links_to_parents(_VIEW_PARENT_ROLES)):
         _view(link_2.item, mapper, level + 1, link_2, validated_filter)
 
 
@@ -577,9 +602,11 @@ def _register_blocks(item: Item, blocks: list[Item],
         return
     for link in itertools.chain(
             item.links_to_children(is_link_enabled=_any_link),
-            item.links_to_parents(
-                ["interface-group-member", "register-block-host"],
-                is_link_enabled=_any_link)):
+            item.links_to_parents([
+                "interface-group-member", "interface-host",
+                "register-block-host"
+            ],
+                                  is_link_enabled=_any_link)):
         _register_blocks(link.item, blocks, visited)
 
 

{specware-1.3.6 → specware-1.3.8}/src/specware/contentc.py

@@ -524,9 +524,16 @@ class CContent(Content):
             self.wrap(description)
 
     @contextmanager
-    def header_guard(self, filename: str) -> Iterator[None]:
-        """ Open a header guard context. """
-        guard = "_" + _NOT_ALPHANUM.sub("_", filename).upper()
+    def header_guard(self,
+                     filename: str,
+                     guard: Optional[str] = None) -> Iterator[None]:
+        """
+        Open a header guard context.
+
+        Without a guard, the guard is derived from the file name.
+        """
+        if guard is None:
+            guard = "_" + _NOT_ALPHANUM.sub("_", filename).upper()
         self.add([f"#ifndef {guard}", f"#define {guard}"])
         yield
         self.add(f"#endif /* {guard} */")

{specware-1.3.6 → specware-1.3.8}/src/specware/interface.py

@@ -67,6 +67,34 @@ def _get_ingroups(item: Item) -> _ItemMap:
     return ingroups
 
 
+def _get_domains(item: Item) -> set[str]:
+    if item["interface-type"] == "domain":
+        return {item.uid}
+    containers = list(item.parents("interface-placement"))
+    containers.extend(link.item for link in get_register_block_hosts(item))
+    domains: set[str] = set()
+    for container in containers:
+        domains.update(_get_domains(container))
+    return domains
+
+
+def _is_hosted_in_second_domain(item: Item) -> bool:
+    return any(True for _ in item.links_to_children("interface-host")) or (
+        bool(get_register_block_hosts(item))
+        and any(True for _ in item.parents("interface-placement")))
+
+
+def _get_ingroups_of_node(item: Item, domain: Item) -> _ItemMap:
+    ingroups = _get_ingroups(item)
+    if _is_hosted_in_second_domain(item):
+        return {
+            uid: group
+            for uid, group in ingroups.items()
+            if domain.uid in _get_domains(group)
+        }
+    return ingroups
+
+
 def _get_group_identifier(item: Item) -> str:
     if item.type == "interface/register-block":
         return get_register_block_identifier(item)
@@ -525,7 +553,7 @@ class _Node:
         self.header_file = header_file
         self.item = item
         self.host = host
-        self.ingroups = _get_ingroups(item)
+        self.ingroups = _get_ingroups_of_node(item, header_file.domain)
         self.dependents: set[_Node] = set()
         self.depends_on: set[_Node] = set()
         self.content = header_file.content.fragment()
@@ -678,7 +706,10 @@ class _Node:
             ctx.regs[name] = {}
             ctx.regs[name]["size"] = link.item["register-block-size"]
             ctx.regs[name]["type"] = link.item["name"]
-            ctx.regs[name]["group"] = get_register_block_identifier(link.item)
+            host = self.header_file.get_host(
+                link.item) if _is_hosted_in_second_domain(link.item) else None
+            ctx.regs[name]["group"] = get_register_block_identifier(
+                link.item, host)
 
     def _get_register_member_info(self, ctx: _RegisterMemberContext) -> None:
         offset = -1
@@ -1236,6 +1267,11 @@ class _HeaderFile:
         self.register_bit_macros = register_bit_macros
         self._option_expressions = option_expressions
 
+    @property
+    def domain(self) -> Item:
+        """ Is the domain of the header file. """
+        return self._item.parent("interface-placement")
+
     def option_expression(self, option: str) -> str:
         """ Get the expression which tests the option in the header file. """
         return self._option_expressions.get_expression(self._item, option)
@@ -1245,18 +1281,32 @@ class _HeaderFile:
         Add the includes of the item to the header file includes.
 
         A register block which header files host adds the host of the domain
-        of this header file.
+        of this header file, unless a header file of this domain places the
+        register block.
         """
-        for parent in item.parents("interface-placement"):
-            if parent.type in [
-                    "interface/header-file",
-                    "interface/unspecified-header-file"
-            ]:
-                self._includes.append(parent)
-        if get_register_block_hosts(item):
-            self._includes.append(
-                get_register_block_host_of_domain(
-                    item, self._item.parent("interface-placement")).item)
+        host = self.get_host(item)
+        if host is None:
+            self._includes.extend(
+                parent for parent in item.parents("interface-placement")
+                if parent.type in
+                ["interface/header-file", "interface/unspecified-header-file"])
+        else:
+            self._includes.append(host.item)
+
+    def get_host(self, item: Item) -> Optional[Link]:
+        """
+        Get the link of the header file of the domain of this header file
+        which hosts the item.
+
+        Returns None, if no header file hosts the item or a header file of the
+        domain places it.
+        """
+        domain = self.domain
+        if not get_register_block_hosts(item) or any(
+                parent.parent("interface-placement") == domain
+                for parent in item.parents("interface-placement")):
+            return None
+        return get_register_block_host_of_domain(item, domain)
 
     def add_node(self, item: Item) -> None:
         """ Add a node for the item. """
@@ -1268,15 +1318,26 @@ class _HeaderFile:
         if item.type != "interface/register-block":
             raise ValueError(f"header file '{self._item.uid}' hosts "
                              f"'{item.uid}' which is no register block")
-        if any(True for _ in item.parents("interface-placement")):
-            raise ValueError(f"register block '{item.uid}' has an interface "
-                             "placement and header file "
-                             f"'{self._item.uid}' hosts it")
-        get_register_block_host_of_domain(
-            item, self._item.parent("interface-placement"))
+        self._check_hosted_item(item)
         node_type = _ZephyrNode if link["style"] == "zephyr" else _Node
         self._nodes[item.uid] = node_type(self, item, link)
 
+    def add_hosted_interface(self, link: Link) -> None:
+        """ Add a node for the interface of the host link. """
+        self._check_hosted_item(link.item)
+        self.add_node(link.item)
+
+    def _check_hosted_item(self, item: Item) -> None:
+        domain = self.domain
+        if any(
+                parent.parent("interface-placement") == domain
+                for parent in item.parents("interface-placement")):
+            kind = item["interface-type"].replace("-", " ")
+            raise ValueError(f"{kind} '{item.uid}' has an interface "
+                             "placement in the domain of header file "
+                             f"'{self._item.uid}' which hosts it")
+        get_register_block_host_of_domain(item, domain)
+
     def add_dependency(self, node: _Node, item: Item) -> None:
         """
         Add a dependency from a node to another node identified by an item if
@@ -1295,6 +1356,9 @@ class _HeaderFile:
         for link in self._item.links_to_parents("register-block-host"):
             self.add_hosted_node(link)
             self.content.register_license_and_copyrights_of_item(link.item)
+        for link in self._item.links_to_parents("interface-host"):
+            self.add_hosted_interface(link)
+            self.content.register_license_and_copyrights_of_item(link.item)
         for node in self._nodes.values():
             node.generate()
 
@@ -1356,7 +1420,8 @@ class _HeaderFile:
     def finalize(self) -> None:
         """ Finalize the header file. """
         self.add_prologue()
-        with self.content.header_guard(self._item["path"]):
+        with self.content.header_guard(self._item["path"],
+                                       self.get_header_guard()):
             exp_mapper = OptionExpressionMapper(self._option_expressions,
                                                 self._item)
             includes = [
@@ -1383,6 +1448,16 @@ class _HeaderFile:
                 for node in self._get_nodes_in_dependency_order():
                     self.content.add(node.content)
 
+    def get_header_guard(self) -> Optional[str]:
+        """
+        Get the header guard of the header file.
+
+        The ``header-guard`` attribute of the placement link of the header file
+        states the guard.  Returns None, if the guard is derived from the path.
+        """
+        link = next(self._item.links_to_parents("interface-placement"))
+        return link.data.get("header-guard", None)
+
     def write(self, domain_path: Optional[str],
               file_path: Optional[str]) -> None:
         """ Write the header file. """

{specware-1.3.6 → specware-1.3.8}/src/specware/interfacedoc.py

@@ -35,6 +35,7 @@ from .contentc import (CContent, DEFAULT_ITEM_MARKER, add_item_marker,
                        get_value_compound, get_value_forward_declaration,
                        get_value_unspecified_type)
 from .interfacemapper import sanitize_name
+from .registerblock import get_interface_members
 
 
 def _get_code_param(ctx: ItemGetValueContext) -> Any:
@@ -309,10 +310,10 @@ _TYPE_GENERATORS = {
 }
 
 
-def _gather_types(item: Item, types: list[Item]) -> None:
-    for child in item.children("interface-placement"):
+def _gather_types(item: Item, types: dict[str, Item]) -> None:
+    for child in get_interface_members(item):
         if child.type in _TYPE_GENERATORS:
-            types.append(child)
+            types[child.uid] = child
         _gather_types(child, types)
 
 
@@ -325,7 +326,7 @@ def _is_opaque_type(item: Item) -> Optional[Item]:
 
 def _generate_types(content: TextContent, mapper: ItemMapper, config: dict,
                     item_cache: ItemCache, item_marker: str) -> None:
-    types: list[Item] = []
+    types: dict[str, Item] = {}
     for domain in config["domains"]:
         _gather_types(item_cache[domain], types)
     content.add_automatically_generated_warning()
@@ -341,7 +342,7 @@ for more information about the usage of the various data types.""")
             content.wrap(
                 "The following is a complete list of the RTEMS primitive data "
                 "types in alphabetical order:")
-            for item in sorted(types, key=lambda x: x["name"]):
+            for item in sorted(types.values(), key=lambda x: x["name"]):
                 content.register_license_and_copyrights_of_item(item)
                 add_item_marker(content, item_marker, item)
                 name = item["name"]

{specware-1.3.6 → specware-1.3.8}/src/specware/registerblock.py

@@ -37,23 +37,28 @@ __all__ = [
     "get_register_block_prefixes"
 ]
 
+_HOST_ROLES = ("interface-host", "register-block-host")
+
 
 def get_register_block_hosts(item: Item) -> list[Link]:
     """
-    Get the links of the header files which host the register block.
+    Get the links of the header files which host the interface.
 
     Each link is a link from the header file to the register block, so
     ``link.item`` is the header file.  The links are sorted by the UID of the
     header file.
     """
-    return sorted(item.links_to_children("register-block-host"),
+    return sorted(item.links_to_children(_HOST_ROLES),
                   key=lambda link: link.item.uid)
 
 
+def _get_kind(item: Item) -> str:
+    return item["interface-type"].replace("-", " ")
+
+
 def get_register_block_host_of_domain(item: Item, domain: Item) -> Link:
     """
-    Get the link of the header file of the domain which hosts the register
-    block.
+    Get the link of the header file of the domain which hosts the interface.
 
     Raises:
         ValueError: No header file or more than one header file of the domain
@@ -65,10 +70,11 @@ def get_register_block_host_of_domain(item: Item, domain: Item) -> Link:
     ]
     if not hosts:
         raise ValueError(f"no header file of domain '{domain.uid}' hosts "
-                         f"register block '{item.uid}'")
+                         f"{_get_kind(item)} '{item.uid}'")
     if len(hosts) > 1:
         raise ValueError(f"more than one header file of domain "
-                         f"'{domain.uid}' hosts register block '{item.uid}': "
+                         f"'{domain.uid}' hosts {_get_kind(item)} "
+                         f"'{item.uid}': "
                          f"{', '.join(link.item.uid for link in hosts)}")
     return hosts[0]
 
@@ -78,10 +84,11 @@ def get_interface_members(item: Item) -> list[Item]:
     Get the interfaces which the interface container places.
 
     These are the children of the ``interface-placement`` links and the
-    register blocks of the ``register-block-host`` links of the container.
+    interfaces of the ``register-block-host`` and ``interface-host`` links of
+    the container.
     """
     return list(item.children("interface-placement")) + list(
-        item.parents("register-block-host"))
+        item.parents(_HOST_ROLES))
 
 
 def get_interface_groups(item: Item) -> list[Item]:
@@ -141,7 +148,7 @@ def _get_block_value(item: Item, host: Optional[Link], key: str) -> Any:
         value = host.data.get(key, None)
         if value is not None:
             return value
-    else:
+    elif not any(True for _ in item.parents("interface-placement")):
         values = set(link.data[key] for link in get_register_block_hosts(item)
                      if link.data.get(key, None) is not None)
         if len(values) > 1:
@@ -164,7 +171,7 @@ def get_register_block_identifier(item: Item,
 
     The value of the host link takes precedence over the value of the block.
     Without a host link, the value of the host links of the block takes
-    precedence.
+    precedence, unless the block has an interface placement.
     """
     return _get_block_value(item, host, "identifier")
 
@@ -175,7 +182,7 @@ def get_register_block_group(item: Item, host: Optional[Link] = None) -> str:
 
     The value of the host link takes precedence over the value of the block.
     Without a host link, the value of the host links of the block takes
-    precedence.
+    precedence, unless the block has an interface placement.
     """
     return _get_block_value(item, host, "register-block-group")
 

{specware-1.3.6 → specware-1.3.8}/src/specware/rtems.py

@@ -52,8 +52,9 @@ _ENABLEMENT_ROLES = ("interface-function", "interface-ingroup",
                      "validation")
 
 # An item is enabled through the items which link to it by these roles.
-_ENABLEMENT_CHILD_ROLES = ("interface-group-member", "register-block-base",
-                           "register-block-host", "register-block-include")
+_ENABLEMENT_CHILD_ROLES = ("interface-host", "interface-group-member",
+                           "register-block-base", "register-block-host",
+                           "register-block-include")
 
 
 def recursive_is_enabled(enabled_set: EnabledSet, item: Item) -> bool:
@@ -141,7 +142,8 @@ _VALIDATION_PARENT_ROLES = _PARENT_ROLES + ("interface-group-member", )
 _VISIT_CHILD_ROLES = _CHILD_ROLES + ("appl-config-group-member",
                                      "interface-placement")
 
-_VISIT_PARENT_ROLES = _VALIDATION_PARENT_ROLES + ("register-block-host", )
+_VISIT_PARENT_ROLES = _VALIDATION_PARENT_ROLES + ("interface-host",
+                                                  "register-block-host")
 
 
 def _visit_tree(item: Item, related_items: set[Item]) -> None:
@@ -171,8 +173,8 @@ _EXPORT_CHILD_ROLES = ("interface-function", "interface-placement",
                        "test-case", "validation")
 
 _EXPORT_PARENT_ROLES = _PARENT_ROLES + (
-    "constraint", "errno", "register-block-base", "register-block-host",
-    "register-block-include")
+    "constraint", "interface-host", "errno", "register-block-base",
+    "register-block-host", "register-block-include")
 
 # Items reached through the shallow roles contribute to the generated content
 # of the visiting item, however, the items related to them do not.  Expanding