can-api-generator 2.0.0__tar.gz → 2.1.0__tar.gz

{can_api_generator-2.0.0 → can_api_generator-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: can-api-generator
-Version: 2.0.0
+Version: 2.1.0
 Summary: Program to generate a 'signal' style CAN API in C
 Project-URL: Documentation, https://sr.ht/~laplace/can-api-generator#readme
 Project-URL: Issues, https://sr.ht/~laplace/can-api-generator/issues
@@ -283,6 +283,26 @@ translation unit. This is sufficient for a single-core MCU where the dispatcher
 case. On weakly-ordered multicore hosts, user code is responsible for inserting the appropriate memory barrier between the decode writes and the pointer
 publish, and between reading the pointer and dereferencing it — the generator does not emit any barriers itself.
 
+### Coexisting APIs and struct-name prefixes
+
+The per-message signal structs (`struct <Message>`) are emitted **without** an include-guard. Two headers that share a message name therefore cannot be included in
+one translation unit unless their struct names are made distinct. (An earlier release briefly wrapped these structs in a `#ifndef STRUCT_<NAME>` guard; that was never
+an intended feature — it silently reused the first header's struct layout when two headers defined the same struct name, hiding real layout mismatches — and has been
+removed.)
+
+To include two generated headers that share message names in one translation unit — for example the API for two versions of the same database — generate them with
+`--prefix-signal-struct-names` and `--prefix-context-struct-names`. Each prefixes the relevant struct type names (and, for the context structs, their include-guard
+tokens) with the CamelCase API prefix already used for `<Prefix>RxSignals` / `<Prefix>TxSignals`, so the two APIs get non-colliding struct names:
+
+```c
+/* generated with LIBRARY_NAME "battery_v2" and both prefix flags */
+struct BatteryV2Message1 { /* ... */ };
+struct BatteryV2MsgRxContext { /* ... */ };   /* guard: #ifndef BATTERYV2MSGRXCONTEXT */
+struct BatteryV2MsgTxContext { /* ... */ };   /* guard: #ifndef BATTERYV2MSGTXCONTEXT */
+```
+
+Both flags are off by default and reuse the existing API prefix — they change struct type *names* only, never layout or field order.
+
 ### RX/TX callback context
 
 Both the [Global RX](#global-rx) and [Periodic TX](#periodic-tx) paths let you register a per-message callback. Without a context flag those callbacks take no arguments
@@ -565,6 +585,10 @@ Options:
   generated and decoded signals reach the application only through the RX callback. See [Global RX](#global-rx). Only meaningful together with `-r`.
 * `--with-rx-valid` — in callback-only mode, add a `valid` field to `MsgRxContext` and set it on each matched frame, for struct-layout compatibility with
   store-based APIs. No effect with `--rx-signal-store`. Only meaningful together with `-r`.
+* `--prefix-signal-struct-names` — prefix every per-message signal struct type name with the CamelCase API prefix (the same prefix used for `<Prefix>RxSignals` /
+  `<Prefix>TxSignals`). Lets two similar APIs (e.g. two versions of one database) coexist in a single translation unit with distinct struct names. Off by default.
+* `--prefix-context-struct-names` — prefix the `MsgRxContext` / `MsgTxContext` type names and their include-guard tokens with the CamelCase API prefix, so the
+  context structs of two coexisting APIs do not share a single definition. Off by default.
 * `-im`, `--id-member-name TEXT` — override the name of the `CanFrame` member that carries the arbitration id (default `arbitration_id`). Used to adapt the API
   to an existing project's frame struct naming.
 * `-lm`, `--length-member-name TEXT` — override the name of the `CanFrame` length member (default `length`).

{can_api_generator-2.0.0 → can_api_generator-2.1.0}/README.md

@@ -258,6 +258,26 @@ translation unit. This is sufficient for a single-core MCU where the dispatcher
 case. On weakly-ordered multicore hosts, user code is responsible for inserting the appropriate memory barrier between the decode writes and the pointer
 publish, and between reading the pointer and dereferencing it — the generator does not emit any barriers itself.
 
+### Coexisting APIs and struct-name prefixes
+
+The per-message signal structs (`struct <Message>`) are emitted **without** an include-guard. Two headers that share a message name therefore cannot be included in
+one translation unit unless their struct names are made distinct. (An earlier release briefly wrapped these structs in a `#ifndef STRUCT_<NAME>` guard; that was never
+an intended feature — it silently reused the first header's struct layout when two headers defined the same struct name, hiding real layout mismatches — and has been
+removed.)
+
+To include two generated headers that share message names in one translation unit — for example the API for two versions of the same database — generate them with
+`--prefix-signal-struct-names` and `--prefix-context-struct-names`. Each prefixes the relevant struct type names (and, for the context structs, their include-guard
+tokens) with the CamelCase API prefix already used for `<Prefix>RxSignals` / `<Prefix>TxSignals`, so the two APIs get non-colliding struct names:
+
+```c
+/* generated with LIBRARY_NAME "battery_v2" and both prefix flags */
+struct BatteryV2Message1 { /* ... */ };
+struct BatteryV2MsgRxContext { /* ... */ };   /* guard: #ifndef BATTERYV2MSGRXCONTEXT */
+struct BatteryV2MsgTxContext { /* ... */ };   /* guard: #ifndef BATTERYV2MSGTXCONTEXT */
+```
+
+Both flags are off by default and reuse the existing API prefix — they change struct type *names* only, never layout or field order.
+
 ### RX/TX callback context
 
 Both the [Global RX](#global-rx) and [Periodic TX](#periodic-tx) paths let you register a per-message callback. Without a context flag those callbacks take no arguments
@@ -540,6 +560,10 @@ Options:
   generated and decoded signals reach the application only through the RX callback. See [Global RX](#global-rx). Only meaningful together with `-r`.
 * `--with-rx-valid` — in callback-only mode, add a `valid` field to `MsgRxContext` and set it on each matched frame, for struct-layout compatibility with
   store-based APIs. No effect with `--rx-signal-store`. Only meaningful together with `-r`.
+* `--prefix-signal-struct-names` — prefix every per-message signal struct type name with the CamelCase API prefix (the same prefix used for `<Prefix>RxSignals` /
+  `<Prefix>TxSignals`). Lets two similar APIs (e.g. two versions of one database) coexist in a single translation unit with distinct struct names. Off by default.
+* `--prefix-context-struct-names` — prefix the `MsgRxContext` / `MsgTxContext` type names and their include-guard tokens with the CamelCase API prefix, so the
+  context structs of two coexisting APIs do not share a single definition. Off by default.
 * `-im`, `--id-member-name TEXT` — override the name of the `CanFrame` member that carries the arbitration id (default `arbitration_id`). Used to adapt the API
   to an existing project's frame struct naming.
 * `-lm`, `--length-member-name TEXT` — override the name of the `CanFrame` length member (default `length`).

{can_api_generator-2.0.0 → can_api_generator-2.1.0}/src/can_api_generator/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2025-present Alexande Becker <nabla.becker@mailbox.org>
 #
 # SPDX-License-Identifier: LGPL-3.0-only
-__version__ = "2.0.0"
+__version__ = "2.1.0"

{can_api_generator-2.0.0 → can_api_generator-2.1.0}/src/can_api_generator/code_generator.py

@@ -1,10 +1,12 @@
 from can_api_generator.msg_processor import CAPIMessage
+from can_api_generator.utils import to_struct_prefix
 from pathlib import Path
 import can_db_model
 
 
 def build_msgs_data_dicts_from_kcd(
-        db_path: Path, api_name: str, node_name: str):
+        db_path: Path, api_name: str, node_name: str,
+        prefix_signal_struct_names: bool = False):
     """Load a KCD or YAML database and build CAPIMessage dicts for NODE_NAME.
 
     Returns (list-of-message-dicts, CanDb). The path may be .kcd or .yaml/.yml;
@@ -16,7 +18,8 @@ def build_msgs_data_dicts_from_kcd(
             msg,
             api_name=api_name,
             node_name=node_name,
-            bus_name=bus_name)
+            bus_name=bus_name,
+            prefix_signal_struct_names=prefix_signal_struct_names)
             for msg in db.messages]
     for msg in msgs:
         for sig in msg.signals:
@@ -42,12 +45,18 @@ def generate_api_implementation(msgs: list[dict],
                                 rx_signal_store: bool = False,
                                 with_rx_valid: bool = False,
                                 msg_as_tx_callback_arg: bool = False,
-                                tx_signal_store: bool = False):
+                                tx_signal_store: bool = False,
+                                prefix_context_struct_names: bool = False):
     header_template = jinja_env.get_template("header_template.jinja")
     source_template = jinja_env.get_template("source_template.jinja")
     canframe_template = jinja_env.get_template("canframe.jinja")
-    lib_name_struct_prefix = ''.join(map(lambda s: s.capitalize(),
-                                         api_name.split('_')))
+    lib_name_struct_prefix = to_struct_prefix(api_name)
+    if prefix_context_struct_names:
+        rx_context_struct_name = lib_name_struct_prefix + "MsgRxContext"
+        tx_context_struct_name = lib_name_struct_prefix + "MsgTxContext"
+    else:
+        rx_context_struct_name = "MsgRxContext"
+        tx_context_struct_name = "MsgTxContext"
     # Callback-only global RX (no store) can only deliver signals through the
     # callback, so the message-as-callback-argument behavior is implied.
     if not rx_signal_store:
@@ -72,6 +81,8 @@ def generate_api_implementation(msgs: list[dict],
         with_rx_valid=with_rx_valid,
         msg_as_tx_callback_arg=msg_as_tx_callback_arg,
         tx_signal_store=tx_signal_store,
+        rx_context_struct_name=rx_context_struct_name,
+        tx_context_struct_name=tx_context_struct_name,
     )
     source_code = source_template.render(
         messages=msgs,
@@ -95,6 +106,8 @@ def generate_api_implementation(msgs: list[dict],
         with_rx_valid=with_rx_valid,
         msg_as_tx_callback_arg=msg_as_tx_callback_arg,
         tx_signal_store=tx_signal_store,
+        rx_context_struct_name=rx_context_struct_name,
+        tx_context_struct_name=tx_context_struct_name,
     )
     canframe_header_code = canframe_template.render(
         arb_id_member_name=arb_id_member_name,

{can_api_generator-2.0.0 → can_api_generator-2.1.0}/src/can_api_generator/main.py

@@ -100,6 +100,17 @@ def main():
                    "periodic TX is callback-only: each scheduled message's "
                    "callback returns the struct to encode, and a NULL return or "
                    "missing callback sends nothing. Only meaningful with -p.")
+@click.option("--prefix-signal-struct-names", is_flag=True, default=False,
+              help="Prefix every per-message signal struct type name with the "
+                   "CamelCase API prefix (the same prefix used for "
+                   "<Prefix>RxSignals / <Prefix>TxSignals), so two similar APIs "
+                   "(e.g. two versions of a database) can coexist in one "
+                   "translation unit with distinct struct names.")
+@click.option("--prefix-context-struct-names", is_flag=True, default=False,
+              help="Prefix the MsgRxContext / MsgTxContext struct type names (and "
+                   "their include-guard tokens) with the CamelCase API prefix, so "
+                   "context structs from two coexisting APIs do not share one "
+                   "definition.")
 @click.option("-v", "--verbose", is_flag=True, default=False,
               help="Print the Data that is passed to the template that "
               "generates the code")
@@ -108,7 +119,8 @@ def api(db_file, library_name, node_name, force, encode_all_signals_func,
         periodic_tx, ti_compatible, send_now, double_buffered,
         rx_callback_context, tx_callback_context, msg_as_rx_callback_arg,
         rx_signal_store, with_rx_valid, msg_as_tx_callback_arg,
-        tx_signal_store, verbose):
+        tx_signal_store, prefix_signal_struct_names,
+        prefix_context_struct_names, verbose):
     """
     Generate the static C API for NODE_NAME from DB_FILE (.kcd or .yaml)
     """
@@ -127,7 +139,9 @@ def api(db_file, library_name, node_name, force, encode_all_signals_func,
     except FileExistsError as e:
         click.echo(e)
     try:
-        msgs, kcd_db = build_msgs_data_dicts_from_kcd(db_path, library_name, node_name)
+        msgs, kcd_db = build_msgs_data_dicts_from_kcd(
+            db_path, library_name, node_name,
+            prefix_signal_struct_names=prefix_signal_struct_names)
     except MessageProcessingException as e:
         click.echo(f"Got Error while processing message {e.can_message_name}"
                    f" for {e.node_name}: {e}")
@@ -164,6 +178,7 @@ def api(db_file, library_name, node_name, force, encode_all_signals_func,
         with_rx_valid=with_rx_valid,
         msg_as_tx_callback_arg=msg_as_tx_callback_arg,
         tx_signal_store=tx_signal_store,
+        prefix_context_struct_names=prefix_context_struct_names,
     )
     with (header_path.parent / 'canframe.h').open('w+') as canframe_header_file:
         canframe_header_file.write(canframe_header)

{can_api_generator-2.0.0 → can_api_generator-2.1.0}/src/can_api_generator/msg_processor.py

@@ -10,7 +10,7 @@ import operator
 import copy
 import random
 from can_db_model.model import MuxMember
-from .utils import is_valid_c_identifier, converrt_to_c_identifier
+from .utils import is_valid_c_identifier, converrt_to_c_identifier, to_struct_prefix
 from .utils import convert_to_cantools_signal_name
 from .utils import get_signal_type_from_range, get_bit_length_from_type
 from .types import SignalType, SignalDirection, ByteOrder, SignalProcessingException, MessageProcessingException
@@ -18,7 +18,8 @@ from .types import SignalType, SignalDirection, ByteOrder, SignalProcessingExcep
 
 class CAPIMessage:
     def __init__(self, msg, api_name: str, node_name: str,
-                 bus_name: str, require_endpoints: bool = True):
+                 bus_name: str, require_endpoints: bool = True,
+                 prefix_signal_struct_names: bool = False):
         """
         msg is a can_db_model.model.Message. bus_name is the database's bus
         name (the model carries the bus at the top level, not per-message).
@@ -34,6 +35,7 @@ class CAPIMessage:
         self.is_extended = msg.extended
         # prefix for the struct names
         self.api_prefix = api_name
+        self.prefix_signal_struct_names = prefix_signal_struct_names
         if msg.length > 8:
             raise MessageProcessingException(
                 "Message too large for v2.0B spec",
@@ -115,9 +117,12 @@ class CAPIMessage:
 
     def struct_name(self):
         if ' ' not in self.name:
-            return ''.join(map(lambda s: s.capitalize(), self.name.split('_')))
+            base = ''.join(map(lambda s: s.capitalize(), self.name.split('_')))
         else:
-            return ''.join(map(lambda s: s.capitalize(), self.name.split()))
+            base = ''.join(map(lambda s: s.capitalize(), self.name.split()))
+        if self.prefix_signal_struct_names:
+            return to_struct_prefix(self.api_prefix) + base
+        return base
 
     def to_dict(self):
         return {

{can_api_generator-2.0.0 → can_api_generator-2.1.0}/src/can_api_generator/templates/declaration_macros.jinja

@@ -1,12 +1,9 @@
 {% macro declare_message_struct(message) -%}
-#ifndef STRUCT_{{ message.struct_name | upper }}
-#define STRUCT_{{ message.struct_name | upper }}
 struct {{ message.struct_name }} {
 {%- for signal in message.all_signals %}
     {{ signal.api_data_type }} {{ signal.name }};
 {%- endfor %}
 };
-#endif
 {%- endmacro %}
 
 {% macro generate_msg_defines(message) -%}

{can_api_generator-2.0.0 → can_api_generator-2.1.0}/src/can_api_generator/templates/header_template.jinja

@@ -35,9 +35,9 @@
 {{ generate_label_defines(message) }}{{ declare_message_struct(message) }}
 {% endfor %}
 {%- if global_rx %}
-{{ define_rx_context_struct(true, 'uint64_t', rx_callback_context=rx_callback_context, msg_as_rx_callback_arg=msg_as_rx_callback_arg, rx_signal_store=rx_signal_store, with_rx_valid=with_rx_valid) }}
+{{ define_rx_context_struct(true, 'uint64_t', rx_callback_context=rx_callback_context, msg_as_rx_callback_arg=msg_as_rx_callback_arg, rx_signal_store=rx_signal_store, with_rx_valid=with_rx_valid, ctx_name=rx_context_struct_name) }}
 
-{{ generate_global_rx_struct(messages, api_name_struct_prefix, double_buffered, rx_signal_store=rx_signal_store) }}
+{{ generate_global_rx_struct(messages, api_name_struct_prefix, double_buffered, rx_signal_store=rx_signal_store, ctx_name=rx_context_struct_name) }}
 
 {{ declare_global_rx_frame_process_function(api_name , api_name_struct_prefix, 'CanFrame', 'uint16_t', 'uint64_t') }};
 {%- if double_buffered and rx_signal_store %}
@@ -46,15 +46,15 @@
 {%- endif %}
 {% endif %}
 {%- if periodic_tx %}
-{{ define_tx_context_struct(true, 'uint16_t', 'uint64_t', send_now, tx_callback_context=tx_callback_context, msg_as_tx_callback_arg=msg_as_tx_callback_arg) }}
+{{ define_tx_context_struct(true, 'uint16_t', 'uint64_t', send_now, tx_callback_context=tx_callback_context, msg_as_tx_callback_arg=msg_as_tx_callback_arg, ctx_name=tx_context_struct_name) }}
 
-{{ generate_global_tx_struct(messages, api_name_struct_prefix, double_buffered, tx_signal_store=tx_signal_store) }}
+{{ generate_global_tx_struct(messages, api_name_struct_prefix, double_buffered, tx_signal_store=tx_signal_store, ctx_name=tx_context_struct_name) }}
 
 {{ declare_periodic_tx_init_function(api_name, api_name_struct_prefix, 'uint64_t') }};
 
-{{ declare_get_msg_tx_context_by_id(messages, api_name, api_name_struct_prefix, 'struct MsgTxContext') }};
+{{ declare_get_msg_tx_context_by_id(messages, api_name, api_name_struct_prefix, 'struct ' ~ tx_context_struct_name) }};
 
-{{ declare_period_update_function(api_name, 'struct MsgTxContext') }}
+{{ declare_period_update_function(api_name, 'struct ' ~ tx_context_struct_name) }}
 
 {{ declare_periodic_tx_function(api_name, api_name_struct_prefix, 'CanFrame', 'uint16_t', 'uint64_t', 'uint16_t') }};
 {%- if double_buffered and tx_signal_store %}

{can_api_generator-2.0.0 → can_api_generator-2.1.0}/src/can_api_generator/templates/rx_macros.jinja

@@ -1,9 +1,9 @@
 {% from "encoding_macros.jinja" import message_match_function_call %}
 {% from "encoding_macros.jinja" import  message_decoding_function_call %}
-{%- macro define_rx_context_struct(rx_callback, time_type, rx_callback_context=false, msg_as_rx_callback_arg=false, rx_signal_store=false, with_rx_valid=false) -%}
-#ifndef MSGRXCTX
-#define MSGRXCTX
-struct MsgRxContext {
+{%- macro define_rx_context_struct(rx_callback, time_type, rx_callback_context=false, msg_as_rx_callback_arg=false, rx_signal_store=false, with_rx_valid=false, ctx_name='MsgRxContext') -%}
+#ifndef {{ ctx_name | upper }}
+#define {{ ctx_name | upper }}
+struct {{ ctx_name }} {
     uint16_t ignore;
 {%- if rx_signal_store or with_rx_valid %}
     uint16_t valid;
@@ -26,11 +26,11 @@ struct MsgRxContext {
 #endif
 {%- endmacro %}
 
-{% macro generate_global_rx_struct(messages, api_struct_prefix, double_buffered=False, rx_signal_store=False) -%}
+{% macro generate_global_rx_struct(messages, api_struct_prefix, double_buffered=False, rx_signal_store=False, ctx_name='MsgRxContext') -%}
 struct {{ api_struct_prefix }}RxSignals {
 {%- for message in messages %}
 {%- if message.direction == 'rx' or message.direction == 'rt' %}
-    struct MsgRxContext {{ message.name }}_context;
+    struct {{ ctx_name }} {{ message.name }}_context;
 {%- if rx_signal_store %}
 {%- if double_buffered %}
     struct {{ message.struct_name }} {{ message.name }}_signals_storage[2];
@@ -73,7 +73,7 @@ struct {{ api_struct_prefix }}RxSignals {{ var_name }};
 {{ api_name }}_process_received_frame({{ rx_signals_ptr_name }}, {{ can_frame_ptr_name }}, {{ time_var_name }})
 {% endmacro %}
 
-{% macro generate_global_rx_frame_process_function(messages, api_name, api_struct_prefix, can_frame_type, return_type, time_type, rx_callback, double_buffered=False, rx_callback_context=false, msg_as_rx_callback_arg=false, rx_signal_store=false, with_rx_valid=false) -%}
+{% macro generate_global_rx_frame_process_function(messages, api_name, api_struct_prefix, can_frame_type, return_type, time_type, rx_callback, double_buffered=False, rx_callback_context=false, msg_as_rx_callback_arg=false, rx_signal_store=false, with_rx_valid=false, ctx_name='MsgRxContext') -%}
 {{ declare_global_rx_frame_process_function(api_name, api_struct_prefix, can_frame_type, return_type, time_type) }} {
 {%- for message in messages %}
 {%- if message.direction == 'rx' or message.direction == 'rt' %}

{can_api_generator-2.0.0 → can_api_generator-2.1.0}/src/can_api_generator/templates/source_template.jinja

@@ -14,7 +14,7 @@
 #include <string.h>
 {%- if global_rx %}
 
-{{ generate_global_rx_frame_process_function(messages, api_name, api_name_struct_prefix, 'CanFrame', 'uint16_t', 'uint64_t', true, double_buffered, rx_callback_context=rx_callback_context, msg_as_rx_callback_arg=msg_as_rx_callback_arg, rx_signal_store=rx_signal_store, with_rx_valid=with_rx_valid) }}
+{{ generate_global_rx_frame_process_function(messages, api_name, api_name_struct_prefix, 'CanFrame', 'uint16_t', 'uint64_t', true, double_buffered, rx_callback_context=rx_callback_context, msg_as_rx_callback_arg=msg_as_rx_callback_arg, rx_signal_store=rx_signal_store, with_rx_valid=with_rx_valid, ctx_name=rx_context_struct_name) }}
 {%- if double_buffered and rx_signal_store %}
 
 {{ define_global_rx_init_function(messages, api_name, api_name_struct_prefix) }}
@@ -22,9 +22,9 @@
 {%- endif %}
 {%- if periodic_tx %}
 
-{{ define_periodic_tx_function(messages, api_name, api_name_struct_prefix, 'CanFrame', 'uint16_t', 'uint64_t', 'uint16_t', true, send_now, double_buffered, tx_callback_context=tx_callback_context, msg_as_tx_callback_arg=msg_as_tx_callback_arg, tx_signal_store=tx_signal_store) }}
+{{ define_periodic_tx_function(messages, api_name, api_name_struct_prefix, 'CanFrame', 'uint16_t', 'uint64_t', 'uint16_t', true, send_now, double_buffered, tx_callback_context=tx_callback_context, msg_as_tx_callback_arg=msg_as_tx_callback_arg, tx_signal_store=tx_signal_store, ctx_name=tx_context_struct_name) }}
 
-{{ define_get_msg_tx_context_by_id(messages, api_name, api_name_struct_prefix, 'struct MsgTxContext') }}
+{{ define_get_msg_tx_context_by_id(messages, api_name, api_name_struct_prefix, 'struct ' ~ tx_context_struct_name) }}
 
 {{ define_periodic_tx_init_function(api_name, api_name_struct_prefix, 'uint64_t', messages, '1000', double_buffered, tx_signal_store=tx_signal_store) }}
 {%- if double_buffered and tx_signal_store %}

{can_api_generator-2.0.0 → can_api_generator-2.1.0}/src/can_api_generator/templates/tx_macros.jinja

@@ -1,10 +1,10 @@
 {% from "encoding_macros.jinja" import message_encoding_function_call %}
 {% from "encoding_macros.jinja" import rotate_multiplex_func_call %}
 
-{% macro define_tx_context_struct(tx_callback, flag_type, time_type, send_now, tx_callback_context=false, msg_as_tx_callback_arg=false) -%}
-#ifndef MSGTXCTX
-#define MSGTXCTX
-struct MsgTxContext {
+{% macro define_tx_context_struct(tx_callback, flag_type, time_type, send_now, tx_callback_context=false, msg_as_tx_callback_arg=false, ctx_name='MsgTxContext') -%}
+#ifndef {{ ctx_name | upper }}
+#define {{ ctx_name | upper }}
+struct {{ ctx_name }} {
     uint32_t arb_id;
     {{ flag_type }} enable;
     {{ time_type }} last_tx;
@@ -58,11 +58,11 @@ static inline void {{ api_name }}_update_tx_period({{ context_type }} *txctx, ui
 }
 {%- endmacro %}
 
-{% macro generate_global_tx_struct(messages, api_struct_prefix, double_buffered=False, tx_signal_store=False) -%}
+{% macro generate_global_tx_struct(messages, api_struct_prefix, double_buffered=False, tx_signal_store=False, ctx_name='MsgTxContext') -%}
 struct {{ api_struct_prefix }}TxSignals {
 {%- for message in messages %}
 {%- if message.direction == 'tx' or message.direction == 'rt' %}
-    struct MsgTxContext {{ message.name }}_context;
+    struct {{ ctx_name }} {{ message.name }}_context;
 {%- if tx_signal_store %}
 {%- if double_buffered %}
     struct {{ message.struct_name }} {{ message.name }}_signals_storage[2];
@@ -93,7 +93,7 @@ void {{ api_name }}_{{ message.name }}_commit(struct {{ api_struct_prefix }}TxSi
 {{ return_type }} {{ api_name }}_periodic_tx(struct {{ api_struct_prefix }}TxSignals *tx_signals, {{ can_frame_type }} *output_frame, {{ time_type }} now)
 {%- endmacro %}
 
-{% macro define_periodic_tx_function(messages, api_name, api_struct_prefix, can_frame_type, return_type, time_type, flag_type, tx_callback, send_now, double_buffered=False, tx_callback_context=false, msg_as_tx_callback_arg=false, tx_signal_store=false) -%}
+{% macro define_periodic_tx_function(messages, api_name, api_struct_prefix, can_frame_type, return_type, time_type, flag_type, tx_callback, send_now, double_buffered=False, tx_callback_context=false, msg_as_tx_callback_arg=false, tx_signal_store=false, ctx_name='MsgTxContext') -%}
 {{ declare_periodic_tx_function(api_name, api_struct_prefix, can_frame_type, return_type, time_type, flag_type) }} {
 {%- for message in messages %}
 {%- if message.direction == 'tx' or message.direction == 'rt' %}

{can_api_generator-2.0.0 → can_api_generator-2.1.0}/src/can_api_generator/utils.py

@@ -24,6 +24,13 @@ def is_valid_c_identifier(s: str) -> bool:
 def converrt_to_c_identifier(input_str: str) -> str:
     return '_'.join(map(lambda s: s.lower(), input_str.split()))
 
+def to_struct_prefix(api_name: str) -> str:
+    """CamelCase an api/library name for use as a C struct-name prefix.
+
+    Mirrors the transform already applied to <Prefix>RxSignals / TxSignals.
+    """
+    return ''.join(map(lambda s: s.capitalize(), api_name.split('_')))
+
 def convert_to_cantools_signal_name(c_signal_identifier: str) -> str:
     """
     Take a C identifier and adapt it to match the cantools name

{can_api_generator-2.0.0 → can_api_generator-2.1.0}/tests/test_cli.py

@@ -622,7 +622,9 @@ def _gen_api_files(tmp_path, api_name, node="DUT", kcd="tests/test_1.kcd",
     here = Path(__file__).resolve().parent
     env = Environment(loader=FileSystemLoader(
         [str(here.parent / "src" / "can_api_generator" / "templates")]))
-    msgs, _ = build_msgs_data_dicts_from_kcd(Path(kcd), api_name, node)
+    msgs, _ = build_msgs_data_dicts_from_kcd(
+        Path(kcd), api_name, node,
+        prefix_signal_struct_names=flags.get("prefix_signal_struct_names", False))
     header, source, canframe = generate_api_implementation(
         msgs, env, api_name, True,
         generate_everything=False,
@@ -635,6 +637,7 @@ def _gen_api_files(tmp_path, api_name, node="DUT", kcd="tests/test_1.kcd",
         tx_signal_store=flags.get("tx_signal_store", False),
         msg_as_tx_callback_arg=flags.get("msg_as_tx_callback_arg", False),
         tx_callback_context=flags.get("tx_callback_context", False),
+        prefix_context_struct_names=flags.get("prefix_context_struct_names", False),
     )
     (tmp_path / f"{api_name}.h").write_text(header)
     (tmp_path / f"{api_name}.c").write_text(source)
@@ -661,20 +664,152 @@ def test_callback_only_rx_zeroes_decode_temp(tmp_path):
     assert decl < memz < decode, "decode temp must be memset before decode"
 
 
-def test_message_struct_is_include_guarded(tmp_path):
-    """Two APIs generated from one KCD with different names must be includable
-    in one translation unit without redefining the shared message structs."""
-    import os
-    import subprocess
+def test_signal_struct_has_no_include_guard(tmp_path):
+    """The per-message signal struct is emitted bare (no STRUCT_ guard)."""
     header, _ = _gen_api_files(tmp_path, "prod", global_rx=True,
                                periodic_tx=True, rx_signal_store=True,
                                tx_signal_store=True)
+    assert "struct Message1 {" in header
+    assert "STRUCT_MESSAGE1" not in header
+    assert "#ifndef STRUCT_" not in header
+
+
+def test_prefix_signal_struct_names_prefixes_struct_type(tmp_path):
+    header, source = _gen_api_files(
+        tmp_path, "prod", global_rx=True, periodic_tx=True,
+        rx_signal_store=True, tx_signal_store=True,
+        prefix_signal_struct_names=True)
+    # struct definition and RX/TX storage members use the prefixed type
+    assert "struct ProdMessage1 {" in header
+    assert "struct ProdMessage2 {" in header
+    assert "struct ProdMessage2 message_2_signals;" in header
+    # encode/decode signatures use the prefixed type
+    assert "struct ProdMessage2 *msg" in source or "struct ProdMessage2 * msg" in source
+    # function names are NOT prefixed with the struct prefix (still api_prefix)
+    assert "prod_message_2_decode" in source
+    assert "struct Message1 {" not in header
+
+
+def test_prefix_signal_struct_names_absent_by_default(tmp_path):
+    header, _ = _gen_api_files(
+        tmp_path, "prod", global_rx=True, periodic_tx=True,
+        rx_signal_store=True, tx_signal_store=True)
+    assert "struct Message1 {" in header
+    assert "ProdMessage1" not in header
+
+
+def test_prefix_signal_struct_names_cli_flag(tmp_path):
+    runner = CliRunner()
+    lib_base = tmp_path / "prod"
+    result = runner.invoke(main, [
+        "api", "tests/test_1.kcd", str(lib_base), "DUT",
+        "-r", "-p", "--rx-signal-store", "--tx-signal-store",
+        "--prefix-signal-struct-names",
+    ])
+    assert result.exit_code == 0, result.output
+    header = (tmp_path / "prod.h").read_text()
+    # The CLI passes the (tmp) library path as api_name, so the exact prefix is
+    # path-derived; assert the flag applied a prefix rather than a specific one.
+    assert "Message1 {" in header            # prefixed struct still ends in Message1
+    assert "struct Message1 {" not in header  # ...but not the bare name
+
+
+def test_prefix_context_struct_names_prefixes_both_contexts(tmp_path):
+    header, source = _gen_api_files(
+        tmp_path, "prod", global_rx=True, periodic_tx=True,
+        rx_signal_store=True, tx_signal_store=True,
+        prefix_context_struct_names=True)
+    # struct definitions + guard tokens follow the prefixed names
+    assert "struct ProdMsgRxContext {" in header
+    assert "struct ProdMsgTxContext {" in header
+    assert "#ifndef PRODMSGRXCONTEXT" in header
+    assert "#ifndef PRODMSGTXCONTEXT" in header
+    # members and signatures use the prefixed context types
+    assert "struct ProdMsgRxContext message_2_context;" in header
+    assert "struct ProdMsgTxContext message_1_context;" in header
+    assert "struct ProdMsgTxContext *prod_get_msg_tx_context_by_id" in header
+    assert "struct MsgRxContext {" not in header
+
+
+def test_prefix_context_struct_names_absent_by_default(tmp_path):
+    header, _ = _gen_api_files(
+        tmp_path, "prod", global_rx=True, periodic_tx=True,
+        rx_signal_store=True, tx_signal_store=True)
+    assert "struct MsgRxContext {" in header
+    assert "struct MsgTxContext {" in header
+    assert "#ifndef MSGRXCONTEXT" in header
+    assert "#ifndef MSGTXCONTEXT" in header
+    assert "ProdMsgRxContext" not in header
+
+
+def test_prefix_context_struct_names_cli_flag(tmp_path):
+    runner = CliRunner()
+    lib_base = tmp_path / "prod"
+    result = runner.invoke(main, [
+        "api", "tests/test_1.kcd", str(lib_base), "DUT",
+        "-r", "-p", "--rx-signal-store", "--tx-signal-store",
+        "--prefix-context-struct-names",
+    ])
+    assert result.exit_code == 0, result.output
+    header = (tmp_path / "prod.h").read_text()
+    # api_name is the tmp path, so assert a prefix was applied, not a specific one.
+    assert "MsgRxContext {" in header
+    assert "struct MsgRxContext {" not in header
+    assert "MsgTxContext {" in header
+    assert "struct MsgTxContext {" not in header
+
+
+# These compile checks pin -std=c11: the generator targets pre-C23 / embedded
+# compilers (e.g. TI C2000), where two same-tag struct definitions in one TU are
+# a redefinition error. C23 (the host gcc default) legalized identical same-tag
+# redefinitions, which would mask the collision the prefixes exist to prevent.
+def test_two_prefixed_builds_coexist_in_one_tu(tmp_path):
+    """Two APIs from one KCD, different names, both prefix flags set, compile
+    together in one translation unit with no redefinition."""
+    import os
+    import subprocess
+    _gen_api_files(tmp_path, "prod", global_rx=True, periodic_tx=True,
+                   rx_signal_store=True, tx_signal_store=True,
+                   prefix_signal_struct_names=True,
+                   prefix_context_struct_names=True)
+    _gen_api_files(tmp_path, "cons", global_rx=True, periodic_tx=True,
+                   rx_signal_store=True, tx_signal_store=True,
+                   prefix_signal_struct_names=True,
+                   prefix_context_struct_names=True)
+    (tmp_path / "both.c").write_text(
+        '#include "prod.h"\n#include "cons.h"\nint main(void) { return 0; }\n')
+    c = subprocess.run(["gcc", "-std=c11", "-c", "-o", os.devnull, "both.c"],
+                       cwd=tmp_path, capture_output=True, text=True)
+    assert c.returncode == 0, c.stderr
+
+
+def test_unprefixed_signal_structs_collide_in_one_tu(tmp_path):
+    """Guard removal is intentional: without --prefix-signal-struct-names, two
+    headers that share a message name no longer coexist in one TU."""
+    import os
+    import subprocess
+    _gen_api_files(tmp_path, "prod", global_rx=True, periodic_tx=True,
+                   rx_signal_store=True, tx_signal_store=True)
     _gen_api_files(tmp_path, "cons", global_rx=True, periodic_tx=True,
                    rx_signal_store=True, tx_signal_store=True)
-    assert "#ifndef STRUCT_MESSAGE1" in header
-    assert "#define STRUCT_MESSAGE1" in header
     (tmp_path / "both.c").write_text(
         '#include "prod.h"\n#include "cons.h"\nint main(void) { return 0; }\n')
-    c = subprocess.run(["gcc", "-c", "-o", os.devnull, "both.c"],
+    c = subprocess.run(["gcc", "-std=c11", "-c", "-o", os.devnull, "both.c"],
+                       cwd=tmp_path, capture_output=True, text=True)
+    assert c.returncode != 0
+    assert "redefinition" in c.stderr and "Message1" in c.stderr
+
+
+def test_prefix_flags_do_not_change_layout_callback_only(tmp_path):
+    """Prefix flags only rename types: a callback-only RX/TX build still
+    compiles and keeps the same field-access shape."""
+    import os
+    import subprocess
+    _gen_api_files(tmp_path, "prod", global_rx=True, periodic_tx=True,
+                   prefix_signal_struct_names=True,
+                   prefix_context_struct_names=True)
+    (tmp_path / "u.c").write_text(
+        '#include "prod.h"\nint main(void) { return 0; }\n')
+    c = subprocess.run(["gcc", "-std=c11", "-c", "-o", os.devnull, "u.c"],
                        cwd=tmp_path, capture_output=True, text=True)
     assert c.returncode == 0, c.stderr

can_api_generator-2.1.0/tests/test_utils.py

@@ -0,0 +1,15 @@
+from src.can_api_generator.utils import to_struct_prefix
+
+
+def test_to_struct_prefix_camelcases_underscore_parts():
+    assert to_struct_prefix("battery_v2") == "BatteryV2"
+
+
+def test_to_struct_prefix_single_token():
+    assert to_struct_prefix("prod") == "Prod"
+
+
+def test_to_struct_prefix_matches_legacy_inline_transform():
+    api_name = "dut_can_a"
+    legacy = "".join(map(lambda s: s.capitalize(), api_name.split("_")))
+    assert to_struct_prefix(api_name) == legacy