Issue/351 (#381)

Generating _Static_assert unless c23 is specified.

Author: thirtytwobits

.github/workflows/test.yml

@@ -141,7 +141,7 @@ jobs:
       matrix:
         architecture: [native32, native, arm-none-eabi]
         compiler: [gcc, clang]
-        language: [c-11, c-11-arr-override, cpp-14, cpp-17, cpp-20]
+        language: [c-11, c-11-arr-override, c-17, c-23, cpp-14, cpp-17, cpp-20]
         exclude:
           - architecture: native32
             compiler: clang

README.rst

@@ -35,7 +35,7 @@ Nunavut ships with built-in support for some programming languages,
 and it can be used to generate code for other languages if custom templates (and some glue logic) are provided.
 Currently, the following languages are supported out of the box:
 
-- **C11** (generates header-only libraries)
+- **C11,c17,c23** (generates header-only libraries)
 - **C++** (generates header-only libraries; `work-in-progress <https://github.com/OpenCyphal/nunavut/issues/91>`_)
 - **Python** (generates Python packages)
 - **HTML** (generates documentation pages)

src/nunavut/_generators.py

@@ -250,6 +250,7 @@ def basic_language_context_builder_from_args(target_language: str, **kwargs: Any
         The following arguments are supported:
 
             * **configuration**: A list of additional configuration files to load.
+            * **option**: Key value arguments to override individual language option values.
             * **include_experimental_languages**: If true then experimental languages will also be available.
             * **language_options**: Opaque arguments passed through to the language objects. The supported arguments and
                 valid values are different depending on the language specified by the :code:`language_key` parameter.
@@ -260,7 +261,7 @@ def basic_language_context_builder_from_args(target_language: str, **kwargs: Any
     :return: A new :class:`LanguageContextBuilder` object based on the command line arguments.
     """
 
-    additional_config_files = kwargs.get("configuration", None)
+    additional_config_files = kwargs.get("configuration")
     if additional_config_files is None:
         additional_config_files = []
     if isinstance(additional_config_files, Path):
@@ -279,6 +280,11 @@ def basic_language_context_builder_from_args(target_language: str, **kwargs: Any
         .add_config_files(*additional_config_files)
     )
 
+    options = kwargs.get("option")
+    if options is not None:
+        for option_key, option_value in options:
+            builder.add_target_language_option_override(option_key, option_value)
+
     return builder
 
 

src/nunavut/_version.py

@@ -9,7 +9,7 @@
 """
 import sys
 
-__version__ = "3.0.0.dev1"  # please update NunavutConfigVersion.cmake if changing the major or minor version.
+__version__ = "3.0.0.dev2"  # please update NunavutConfigVersion.cmake if changing the major or minor version.
 __license__ = "MIT"
 __author__ = "OpenCyphal"
 __copyright__ = (

src/nunavut/cli/__init__.py

@@ -12,7 +12,7 @@
 import sys
 import textwrap
 from pathlib import Path
-from typing import Any, Optional, Type, TypeVar, cast
+from typing import Any, Optional, Tuple, Type, TypeVar, cast
 
 
 class _LazyVersionAction(argparse._VersionAction):
@@ -37,6 +37,26 @@ def __call__(
         parser.exit()
 
 
+def keyvalue(arg: str) -> Tuple[str, Any]:
+    """
+    Parse a key=value string into a tuple.
+
+    :param arg: String in the format "key=value"
+    :return: Tuple of (key, value)
+    :raises ValueError: If the string is not in key=value format
+    """
+    try:
+        key, value = arg.split("=", 1)
+        value_stripped: Any = value.strip()
+        if value_stripped == "false":
+            value_stripped = False
+        elif value_stripped == "true":
+            value_stripped = True
+        return (key.strip(), value_stripped)
+    except ValueError:
+        raise ValueError(f'"{arg}" is not in key=value format') from None
+
+
 ParserT = TypeVar("ParserT")
 """
 Type variable for the concrete parser to create.
@@ -310,14 +330,14 @@ def _make_parser(parser_type: Type[ParserT]) -> ParserT:
 
             # looks for all_types.j2 in the c_jinja template directory and generates
             # generated/include/all_types.h from all types in all DSDL namespaces.
-            nnvg --index-file all_types.h --outdir generated/include --templates c_jinja \
-                path/to/types/animal:cat.1.0.dsdl \
+            nnvg --index-file all_types.h --outdir generated/include --templates c_jinja \\
+                path/to/types/animal:cat.1.0.dsdl \\
                 path/to/types/animal:dog.1.0.dsdl
 
             # looks for manifest.j2 in the json_jinja template directory and generates
             # generated/include/manifest.json from all types in all DSDL namespaces.
-            nnvg --index-file include/manifest.json --outdir generated --templates json_jinja \
-                path/to/types/animal:cat.1.0.dsdl \
+            nnvg --index-file include/manifest.json --outdir generated --templates json_jinja \\
+                path/to/types/animal:cat.1.0.dsdl \\
                 path/to/types/animal:dog.1.0.dsdl
 
     """
@@ -344,7 +364,7 @@ def _make_parser(parser_type: Type[ParserT]) -> ParserT:
     )
 
     def extension_type(raw_arg: str) -> str:
-        if len(raw_arg) > 0 and not raw_arg.startswith("."):
+        if raw_arg and not raw_arg.startswith("."):
             return "." + raw_arg
         else:
             return raw_arg
@@ -823,7 +843,7 @@ def extension_type(raw_arg: str) -> str:
     ln_opt_group.add_argument(
         "--language-standard",
         "-std",
-        choices=["c11", "c++14", "cetl++14-17", "c++17", "c++17-pmr", "c++20", "c++20-pmr"],
+        choices=["c11", "c17", "c23", "c++14", "cetl++14-17", "c++17", "c++17-pmr", "c++20", "c++20-pmr"],
         help=textwrap.dedent(
             """
 
@@ -870,6 +890,29 @@ def extension_type(raw_arg: str) -> str:
         ).lstrip(),
     )
 
+    ln_opt_group.add_argument(
+        "--option",
+        "-o",
+        nargs="*",
+        type=keyvalue,
+        help=textwrap.dedent(
+            """
+        Passes a key=value pair to the template as a language option overriding default options where they are
+        specified. This is useful for passing options to the template that are not available as command-line
+        arguments. For example, if you have a template that uses the
+        "foo" variable you can pass a value to it using this argument::
+
+            nnvg -o foo=value ...
+
+        where "foo" is then available in the template as `{{ options.foo }}`.
+
+        This option is similar to the `--configuration` option but only applies to the options section of the target
+        language and doesn't require a file to be created.
+
+    """
+        ).lstrip(),
+    )
+
     return cast(ParserT, parser)
 
 

src/nunavut/cli/parsers.py

@@ -100,6 +100,7 @@ class NunavutArgumentParser(argparse.ArgumentParser):
     """
 
     DSDL_FILE_SUFFIXES = (".uavcan", ".dsdl")
+    MAX_LOG_ENTRY_LENGTH = 1000
 
     # --[ OVERRIDE ]--------------------------------------------------------------------------------------------------
     def parse_known_args(self, args=None, namespace=None):  # type: ignore
@@ -108,13 +109,79 @@ def parse_known_args(self, args=None, namespace=None):  # type: ignore
         return (parsed_args, argv)
 
     # --[ PRIVATE ]---------------------------------------------------------------------------------------------------
+
+    @staticmethod
+    def _sanitize_log_message(message: str) -> str:
+        """
+        Sanitize a message before logging by:
+        1. Removing control characters
+        2. Replacing newlines and tabs with spaces
+        3. Limiting length
+
+        :param: Raw message to sanitize
+
+        :return: Sanitized message safe for logging
+
+         .. invisible-code-block: python
+
+            from nunavut.cli.parsers import NunavutArgumentParser
+
+            # Control characters
+            message = "This is a test message with control characters \\x00\\x01."
+            sanitized_message = "This is a test message with control characters ."
+            assert sanitized_message == NunavutArgumentParser._sanitize_log_message(message)
+
+            # Newlines and tabs
+            message = "This is a\\r\\ntest\\tmessage with newlines and tabs.\\n\\t"
+            sanitized_message = "This is a test message with newlines and tabs."
+            assert sanitized_message == NunavutArgumentParser._sanitize_log_message(message)
+
+            # Multiple spaces
+            message = "This is a test message    with    multiple    spaces."
+            sanitized_message = "This is a test message with multiple spaces."
+            assert sanitized_message == NunavutArgumentParser._sanitize_log_message(message)
+
+            # Stripping whitespace
+            message = "   This is a test message with leading and trailing whitespace.   "
+            sanitized_message = "This is a test message with leading and trailing whitespace."
+            assert sanitized_message == NunavutArgumentParser._sanitize_log_message(message)
+
+            # Length limit
+            message_preamble = "This is a test message"
+            message = message_preamble + "a" * NunavutArgumentParser.MAX_LOG_ENTRY_LENGTH
+            sanitized_message = (
+                message_preamble +
+                "a" * (NunavutArgumentParser.MAX_LOG_ENTRY_LENGTH - len(message_preamble)) + "... (truncated)"
+            )
+            assert sanitized_message == NunavutArgumentParser._sanitize_log_message(message)
+
+        """
+        # Remove control characters except whitespace
+        message = "".join(char for char in message if char.isprintable() or char.isspace())
+
+        # Replace newlines and tabs with spaces
+        message = re.sub(r"[\n\r\t]+", " ", message)
+
+        # Collapse multiple spaces
+        message = re.sub(r"\s+", " ", message)
+
+        # Trim whitespace
+        message = message.strip()
+
+        # Limit length to prevent log flooding
+        if len(message) > NunavutArgumentParser.MAX_LOG_ENTRY_LENGTH:
+            message = message[: NunavutArgumentParser.MAX_LOG_ENTRY_LENGTH] + "... (truncated)"
+
+        return message
+
     def _post_process_log(self, args: argparse.Namespace, message: str) -> None:
         """
         Print a message to the log.
         """
         if args.verbose <= 0:
             return
-        self._print_message(message, sys.stdout)
+        sanitary_message = self._sanitize_log_message(message)
+        self._print_message(sanitary_message, sys.stdout)
 
     def _post_process_args(self, args: argparse.Namespace) -> None:
         """

src/nunavut/lang/__init__.py

@@ -66,7 +66,7 @@ class LanguageContextBuilder:
 
     def __init__(self, include_experimental_languages: bool = False):
         self._target_language_name: typing.Optional[str] = None
-        self._target_language_config: typing.Dict[str, str] = {}
+        self._target_language_config: typing.Dict[str, typing.Any] = {}
         self._ln_loader = LanguageClassLoader()
         self._include_experimental_languages = include_experimental_languages
 
@@ -163,6 +163,82 @@ def set_target_language_configuration_override(self, key: str, value: typing.Any
             self._target_language_config[key] = value
         return self
 
+    def add_target_language_option_override(self, key: str, value: typing.Any) -> "LanguageContextBuilder":
+        """
+        Adds a key and value to override in the language options section of the configuration for a language target
+        when a LanguageContext is crated. These overrides are always set under the language section of the target
+        language.
+
+        .. invisible-code-block: python
+
+            from nunavut.lang import LanguageContextBuilder, Language, LanguageClassLoader
+
+        .. code-block:: python
+
+            builder = LanguageContextBuilder().set_target_language("c")
+            c_section_name = LanguageClassLoader.to_language_module_name("c")
+
+            default_c_language_options = builder.config.get_config_value_as_dict(
+                                            c_section_name,
+                                            Language.WKCV_LANGUAGE_OPTIONS)
+
+            assert default_c_language_options["std"] == "c11"
+
+        We can now try to override the default standard for a future "C" target language object:
+
+        .. code-block:: python
+
+            builder.add_target_language_option_override("std", "c17")
+
+        ...but that value will not be overridden until you create the target language:
+
+        .. code-block:: python
+
+
+            default_c_language_options = builder.config.get_config_value_as_dict(
+                                            c_section_name,
+                                            Language.WKCV_LANGUAGE_OPTIONS)
+
+            assert default_c_language_options["std"] == "c11"
+
+            _ = builder.create()
+
+            overridden_c_language_options = builder.config.get_config_value_as_dict(
+                                            c_section_name,
+                                            Language.WKCV_LANGUAGE_OPTIONS)
+
+            assert default_c_language_options["std"] == "c17"
+
+        Note that the config is scoped by the builder but is then inherited by the language objects created by the
+        builder in the same way as the configuration overrides.
+
+        .. invisible-code-block: python
+
+            from pytest import raises
+
+            builder = LanguageContextBuilder().set_target_language("c")
+            c_section_name = LanguageClassLoader.to_language_module_name("c")
+            builder.set_target_language_configuration_override(
+                Language.WKCV_LANGUAGE_OPTIONS,
+                "wrong type"
+            )
+            with raises(ValueError):
+                builder.add_target_language_option_override("std", "c17")
+            # This will raise a ValueError because the WKCV_LANGUAGE_OPTIONS is not a dict.
+
+        """
+        if value is not None:
+            options = self._target_language_config.get(Language.WKCV_LANGUAGE_OPTIONS)
+            if options is None:
+                options = {}
+                self._target_language_config[Language.WKCV_LANGUAGE_OPTIONS] = options
+            if not isinstance(options, dict):
+                raise ValueError(
+                    f"Cannot set target language option override for {key} because the value is not a dict."
+                )
+            options[key] = value
+        return self
+
     def set_target_language_extension(
         self, target_language_extension: typing.Optional[str]
     ) -> "LanguageContextBuilder":