odxtools 6.7.1__py3-none-any.whl → 7.1.0__py3-none-any.whl

odxtools/basicstructure.py

@@ -4,6 +4,8 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, cast
 from xml.etree import ElementTree
 
+from typing_extensions import override
+
 from .complexdop import ComplexDop
 from .dataobjectproperty import DataObjectProperty
 from .decodestate import DecodeState
@@ -54,32 +56,29 @@ class BasicStructure(ComplexDop):
             return 8 * self.byte_size
 
         cursor = 0
-        length = 0
+        byte_length = 0
         for param in self.parameters:
             param_bit_length = param.get_static_bit_length()
             if param_bit_length is None:
                 # We were not able to calculate a static bit length
                 return None
             elif param.byte_position is not None:
-                bit_pos = param.bit_position or 0
-                byte_pos = param.byte_position or 0
-                cursor = byte_pos * 8 + bit_pos
+                cursor = param.byte_position
 
-            cursor += param_bit_length
-            length = max(length, cursor)
+            cursor += ((param.bit_position or 0) + param_bit_length + 7) // 8
+            byte_length = max(byte_length, cursor)
 
         # Round up to account for padding bits (all structures are
         # byte aligned)
-        return ((length + 7) // 8) * 8
+        return byte_length * 8
 
     def coded_const_prefix(self, request_prefix: bytes = b'') -> bytes:
-        prefix = b''
-        encode_state = EncodeState(
-            bytearray(prefix), parameter_values={}, triggering_request=request_prefix)
+        encode_state = EncodeState(coded_message=bytearray(), triggering_request=request_prefix)
+
         for param in self.parameters:
-            if isinstance(param, (CodedConstParameter, NrcConstParameter, MatchingRequestParameter,
-                                  PhysicalConstantParameter)):
-                encode_state.coded_message = bytearray(param.encode_into_pdu(encode_state))
+            if (isinstance(param, MatchingRequestParameter) and param.request_byte_position < len(request_prefix)) or \
+                isinstance(param, (CodedConstParameter, NrcConstParameter, PhysicalConstantParameter)):
+                param.encode_into_pdu(physical_value=None, encode_state=encode_state)
             else:
                 break
         return encode_state.coded_message
@@ -116,58 +115,101 @@ class BasicStructure(ComplexDop):
 
         print(parameter_info(self.free_parameters), end="")
 
-    def convert_physical_to_internal(self,
-                                     param_value: ParameterValue,
-                                     triggering_coded_request: Optional[bytes],
-                                     is_end_of_pdu: bool = True) -> bytes:
+    def _validate_coded_message_size(self, coded_byte_len: int) -> None:
+
+        if self.byte_size is not None:
+            # We definitely broke something if we didn't respect the explicit byte_size
+            if self.byte_size != coded_byte_len:
+                warnings.warn(
+                    "Verification of coded message failed: Incorrect size.",
+                    OdxWarning,
+                    stacklevel=1)
+
+            return
+
+        bit_length = self.get_static_bit_length()
+
+        if bit_length is None:
+            # Nothing to check
+            return
+
+        if coded_byte_len * 8 != bit_length:
+            # We may have broke something
+            # but it could be that bit_length was mis calculated and not the actual bytes are wrong
+            # Could happen with overlapping parameters and parameters with gaps
+            warnings.warn(
+                "Verification of coded message possibly failed: Size may be incorrect.",
+                OdxWarning,
+                stacklevel=1)
 
-        if not isinstance(param_value, dict):
-            raise EncodeError(
+    @override
+    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+                        encode_state: EncodeState) -> None:
+        if not isinstance(physical_value, dict):
+            odxraise(
                 f"Expected a dictionary for the values of structure {self.short_name}, "
-                f"got {type(param_value)}")
+                f"got {type(physical_value).__name__}", EncodeError)
+        elif encode_state.cursor_bit_position != 0:
+            odxraise(
+                f"Structures must be byte aligned, but "
+                f"{self.short_name} requested to be at bit position "
+                f"{encode_state.cursor_bit_position}", EncodeError)
+            encode_state.bit_position = 0
+
+        orig_cursor = encode_state.cursor_byte_position
+        orig_origin = encode_state.origin_byte_position
+        encode_state.origin_byte_position = encode_state.cursor_byte_position
+
+        orig_is_end_of_pdu = encode_state.is_end_of_pdu
+        encode_state.is_end_of_pdu = False
 
         # in strict mode, ensure that no values for unknown parameters are specified.
         if strict_mode:
-            param_names = [param.short_name for param in self.parameters]
-            for param_key in param_value:
-                if param_key not in param_names:
-                    odxraise(f"Value for unknown parameter '{param_key}' specified")
-
-        encode_state = EncodeState(
-            bytearray(),
-            dict(param_value),
-            triggering_request=triggering_coded_request,
-            is_end_of_pdu=False,
-        )
+            param_names = {param.short_name for param in self.parameters}
+            for param_value_name in physical_value:
+                if param_value_name not in param_names:
+                    odxraise(f"Value for unknown parameter '{param_value_name}' specified "
+                             f"for structure {self.short_name}")
 
         for param in self.parameters:
-            if param == self.parameters[-1]:
-                # The last parameter is at the end of the PDU if the
-                # structure itself is at the end of the PDU. TODO:
-                # This assumes that the last parameter specified in
-                # the ODX is located last in the PDU...
-                encode_state.is_end_of_pdu = is_end_of_pdu
-
-            if isinstance(
-                    param,
-                (LengthKeyParameter, TableKeyParameter)) and param.short_name in param_value:
-                # This is a hack to always encode a dummy value for
-                # length- and table keys. since these can be specified
+            if id(param) == id(self.parameters[-1]):
+                # The last parameter of the structure is at the end of
+                # the PDU if the structure itself is at the end of the
+                # PDU. TODO: This assumes that the last parameter
+                # specified in the ODX is located last in the PDU...
+                encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+            if isinstance(param, (LengthKeyParameter, TableKeyParameter)):
+                # At this point, we encode a placeholder value for length-
+                # and table keys, since these can be specified
                 # implicitly (i.e., by means of parameters that use
-                # these keys), to avoid getting an "overlapping
+                # these keys). To avoid getting an "overlapping
                 # parameter" warning, we must encode a value of zero
                 # into the PDU here and add the real value of the
-                # parameter in a post processing step.
-                tmp = encode_state.parameter_values.pop(param.short_name)
-                encode_state.coded_message = bytearray(param.encode_into_pdu(encode_state))
-                encode_state.parameter_values[param.short_name] = tmp
+                # parameter in a post-processing step.
+                param.encode_placeholder_into_pdu(
+                    physical_value=physical_value.get(param.short_name), encode_state=encode_state)
+
                 continue
 
-            encode_state.coded_message = bytearray(param.encode_into_pdu(encode_state))
+            if param.is_required and param.short_name not in physical_value:
+                odxraise(f"No value for required parameter {param.short_name} specified",
+                         EncodeError)
 
-        if self.byte_size is not None and len(encode_state.coded_message) < self.byte_size:
-            # Padding bytes needed
-            encode_state.coded_message = encode_state.coded_message.ljust(self.byte_size, b"\0")
+            param.encode_into_pdu(
+                physical_value=physical_value.get(param.short_name), encode_state=encode_state)
+
+        encode_state.is_end_of_pdu = False
+        if self.byte_size is not None:
+            actual_len = encode_state.cursor_byte_position - encode_state.origin_byte_position
+            if actual_len < self.byte_size:
+                # Padding bytes needed. We add an empty object at the
+                # position directly after the structure and let
+                # EncodeState add the padding as needed.
+                encode_state.cursor_byte_position = encode_state.origin_byte_position + self.byte_size
+                # Padding bytes needed. these count as "used".
+                encode_state.coded_message += b"\x00" * (self.byte_size - actual_len)
+                encode_state.used_mask += b"\xff" * (self.byte_size - actual_len)
 
         # encode the length- and table keys. This cannot be done above
         # because we allow these to be defined implicitly (i.e. they
@@ -177,56 +219,17 @@ class BasicStructure(ComplexDop):
                 # the current parameter is neither a length- nor a table key
                 continue
 
-            # Encode the key parameter into the message
-            encode_state.coded_message = bytearray(param.encode_into_pdu(encode_state))
+            # Encode the value of the key parameter into the message
+            param.encode_value_into_pdu(encode_state=encode_state)
 
         # Assert that length is as expected
-        self._validate_coded_message(encode_state.coded_message)
-
-        return bytearray(encode_state.coded_message)
-
-    def _validate_coded_message(self, coded_message: bytes) -> None:
-
-        if self.byte_size is not None:
-            # We definitely broke something if we didn't respect the explicit byte_size
-            odxassert(
-                len(coded_message) == self.byte_size,
-                "Verification of coded message {coded_message.hex()} failed: Incorrect size.")
-            # No need to check further
-            return
-
-        bit_length = self.get_static_bit_length()
-
-        if bit_length is None:
-            # Nothing to check
-            return
+        self._validate_coded_message_size(encode_state.cursor_byte_position -
+                                          encode_state.origin_byte_position)
 
-        if len(coded_message) * 8 != bit_length:
-            # We may have broke something
-            # but it could be that bit_length was mis calculated and not the actual bytes are wrong
-            # Could happen with overlapping parameters and parameters with gaps
-            warnings.warn(
-                f"Verification of coded message '{coded_message.hex()}' possibly failed: Size may be incorrect.",
-                OdxWarning,
-                stacklevel=1)
-
-    def convert_physical_to_bytes(self,
-                                  physical_value: ParameterValue,
-                                  encode_state: EncodeState,
-                                  bit_position: int = 0) -> bytes:
-        if not isinstance(physical_value, dict):
-            raise EncodeError(
-                f"Expected a dictionary for the values of structure {self.short_name}, "
-                f"got {type(physical_value)}")
-        if bit_position != 0:
-            raise EncodeError("Structures must be aligned, i.e. bit_position=0, but "
-                              f"{self.short_name} was passed the bit position {bit_position}")
-        return self.convert_physical_to_internal(
-            physical_value,
-            triggering_coded_request=encode_state.triggering_request,
-            is_end_of_pdu=encode_state.is_end_of_pdu,
-        )
+        encode_state.origin_byte_position = orig_origin
+        encode_state.cursor_byte_position = max(orig_cursor, encode_state.cursor_byte_position)
 
+    @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         # move the origin since positions specified by sub-parameters of
         # structures are relative to the beginning of the structure object.
@@ -244,19 +247,6 @@ class BasicStructure(ComplexDop):
 
         return result
 
-    def encode(self, coded_request: Optional[bytes] = None, **params: ParameterValue) -> bytes:
-        """
-        Composes an UDS message as bytes for this service.
-        Parameters:
-        ----------
-        coded_request: bytes
-            coded request (only needed when encoding a response)
-        params: dict
-            Parameters of the RPC as mapping from SHORT-NAME of the parameter to the value
-        """
-        return self.convert_physical_to_internal(
-            params, triggering_coded_request=coded_request, is_end_of_pdu=True)
-
     def decode(self, message: bytes) -> ParameterValueDict:
         decode_state = DecodeState(coded_message=message)
         param_values = self.decode_from_pdu(decode_state)
@@ -316,4 +306,4 @@ class BasicStructure(ComplexDop):
         super()._resolve_snrefs(diag_layer)
 
         for param in self.parameters:
-            param._resolve_snrefs(diag_layer)
+            param._parameter_resolve_snrefs(diag_layer, param_list=self.parameters)

odxtools/dataobjectproperty.py

@@ -120,10 +120,7 @@ class DataObjectProperty(DopBase):
 
         return self.compu_method.convert_physical_to_internal(physical_value)
 
-    def convert_physical_to_bytes(self,
-                                  physical_value: Any,
-                                  encode_state: EncodeState,
-                                  bit_position: int = 0) -> bytes:
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
         """
         Convert a physical representation of a parameter to a string bytes that can be send over the wire
         """
@@ -132,9 +129,8 @@ class DataObjectProperty(DopBase):
                 f"The value {repr(physical_value)} of type {type(physical_value).__name__}"
                 f" is not a valid.")
 
-        internal_val = self.convert_physical_to_internal(physical_value)
-        return self.diag_coded_type.convert_internal_to_bytes(
-            internal_val, encode_state, bit_position=bit_position)
+        internal_value = self.convert_physical_to_internal(physical_value)
+        self.diag_coded_type.encode_into_pdu(internal_value, encode_state)
 
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
         """

odxtools/decodestate.py

@@ -15,18 +15,6 @@ except ImportError:
 if TYPE_CHECKING:
     from .tablerow import TableRow
 
-# format specifiers for the data type using the bitstruct module
-ODX_TYPE_TO_FORMAT_LETTER = {
-    DataType.A_INT32: "s",
-    DataType.A_UINT32: "u",
-    DataType.A_FLOAT32: "f",
-    DataType.A_FLOAT64: "f",
-    DataType.A_BYTEFIELD: "r",
-    DataType.A_UNICODE2STRING: "r",  # UTF-16 strings must be converted explicitly
-    DataType.A_ASCIISTRING: "r",
-    DataType.A_UTF8STRING: "r",
-}
-
 
 @dataclass
 class DecodeState:
@@ -94,7 +82,7 @@ class DecodeState:
 
         padding = (8 - (bit_length + self.cursor_bit_position) % 8) % 8
         internal_value, = bitstruct.unpack_from(
-            f"{ODX_TYPE_TO_FORMAT_LETTER[base_data_type]}{bit_length}",
+            f"{base_data_type.bitstruct_format_letter}{bit_length}",
             extracted_bytes,
             offset=padding)
 

odxtools/diagcodedtype.py

@@ -1,19 +1,14 @@
 # SPDX-License-Identifier: MIT
 import abc
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Dict, Literal, Optional, Union
 
-from .decodestate import ODX_TYPE_TO_FORMAT_LETTER, DecodeState
+from .decodestate import DecodeState
 from .encodestate import EncodeState
-from .exceptions import EncodeError, odxassert, odxraise
+from .exceptions import odxassert, odxraise
 from .odxlink import OdxLinkDatabase, OdxLinkId
 from .odxtypes import AtomicOdxType, DataType
 
-try:
-    import bitstruct.c as bitstruct
-except ImportError:
-    import bitstruct
-
 if TYPE_CHECKING:
     from .diaglayer import DiagLayer
 
@@ -56,88 +51,6 @@ class DiagCodedType(abc.ABC):
     def is_highlow_byte_order(self) -> bool:
         return self.is_highlow_byte_order_raw in [None, True]
 
-    @staticmethod
-    def _encode_internal_value(
-        internal_value: AtomicOdxType,
-        bit_position: int,
-        bit_length: int,
-        base_data_type: DataType,
-        is_highlow_byte_order: bool,
-    ) -> bytes:
-        """Convert the internal_value to bytes."""
-        # Check that bytes and strings actually fit into the bit length
-        if base_data_type == DataType.A_BYTEFIELD:
-            if isinstance(internal_value, bytearray):
-                internal_value = bytes(internal_value)
-            if not isinstance(internal_value, bytes):
-                odxraise()
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The bytefield {internal_value.hex()} is too large "
-                                  f"({len(internal_value)} bytes)."
-                                  f" The maximum length is {bit_length//8}.")
-        if base_data_type == DataType.A_ASCIISTRING:
-            if not isinstance(internal_value, str):
-                odxraise()
-
-            # The spec says ASCII, meaning only byte values 0-127.
-            # But in practice, vendors use iso-8859-1, aka latin-1
-            # reason being iso-8859-1 never fails since it has a valid
-            # character mapping for every possible byte sequence.
-            internal_value = internal_value.encode("iso-8859-1")
-
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The string {repr(internal_value)} is too large."
-                                  f" The maximum number of characters is {bit_length//8}.")
-        elif base_data_type == DataType.A_UTF8STRING:
-            if not isinstance(internal_value, str):
-                odxraise()
-
-            internal_value = internal_value.encode("utf-8")
-
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The string {repr(internal_value)} is too large."
-                                  f" The maximum number of bytes is {bit_length//8}.")
-
-        elif base_data_type == DataType.A_UNICODE2STRING:
-            if not isinstance(internal_value, str):
-                odxraise()
-
-            text_encoding = "utf-16-be" if is_highlow_byte_order else "utf-16-le"
-            internal_value = internal_value.encode(text_encoding)
-
-            if 8 * len(internal_value) > bit_length:
-                raise EncodeError(f"The string {repr(internal_value)} is too large."
-                                  f" The maximum number of characters is {bit_length//16}.")
-
-        # If the bit length is zero, return empty bytes
-        if bit_length == 0:
-            if (base_data_type.value in [
-                    DataType.A_INT32, DataType.A_UINT32, DataType.A_FLOAT32, DataType.A_FLOAT64
-            ] and base_data_type.value != 0):
-                raise EncodeError(
-                    f"The number {repr(internal_value)} cannot be encoded into {bit_length} bits.")
-            return b''
-
-        char = ODX_TYPE_TO_FORMAT_LETTER[base_data_type]
-        padding = (8 - ((bit_length + bit_position) % 8)) % 8
-        odxassert((0 <= padding and padding < 8 and (padding + bit_length + bit_position) % 8 == 0),
-                  f"Incorrect padding {padding}")
-        left_pad = f"p{padding}" if padding > 0 else ""
-
-        # actually encode the value
-        coded = bitstruct.pack(f"{left_pad}{char}{bit_length}", internal_value)
-
-        # apply byte order for numeric objects
-        if not is_highlow_byte_order and base_data_type in [
-                DataType.A_INT32,
-                DataType.A_UINT32,
-                DataType.A_FLOAT32,
-                DataType.A_FLOAT64,
-        ]:
-            coded = coded[::-1]
-
-        return cast(bytes, coded)
-
     def _minimal_byte_length_of(self, internal_value: Union[bytes, str]) -> int:
         """Helper method to get the minimal byte length.
         (needed for LeadingLength- and MinMaxLengthType)
@@ -160,11 +73,10 @@ class DiagCodedType(abc.ABC):
             odxassert(
                 byte_length % 2 == 0, f"The bit length of A_UNICODE2STRING must"
                 f" be a multiple of 16 but is {8*byte_length}")
+
         return byte_length
 
-    @abc.abstractmethod
-    def convert_internal_to_bytes(self, internal_value: AtomicOdxType, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
+    def encode_into_pdu(self, internal_value: AtomicOdxType, encode_state: EncodeState) -> None:
         """Encode the internal value.
 
         Parameters
@@ -177,9 +89,9 @@ class DiagCodedType(abc.ABC):
             mapping from ID (of the length key) to bit length
             (only needed for ParamLengthInfoType)
         """
-        pass
+        raise NotImplementedError(
+            f".encode_into_pdu() is not implemented by the class {type(self).__name__}")
 
-    @abc.abstractmethod
     def decode_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
         """Decode the parameter value from the coded message.
 
@@ -195,4 +107,5 @@ class DiagCodedType(abc.ABC):
         int
             the next byte position after the extracted parameter
         """
-        pass
+        raise NotImplementedError(
+            f".decode_from_pdu() is not implemented by the class {type(self).__name__}")

odxtools/diagcomm.py

@@ -11,7 +11,7 @@ from .element import IdentifiableElement
 from .exceptions import odxraise, odxrequire
 from .functionalclass import FunctionalClass
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import odxstr_to_bool
 from .specialdatagroup import SpecialDataGroup
 from .state import State
@@ -211,5 +211,13 @@ class DiagComm(IdentifiableElement):
         for sdg in self.sdgs:
             sdg._resolve_snrefs(diag_layer)
 
-        self._protocols = NamedItemList(
-            [diag_layer.protocols[prot_snref] for prot_snref in self.protocol_snrefs])
+        if TYPE_CHECKING:
+            self._protocols = NamedItemList([
+                resolve_snref(prot_snref, diag_layer.protocols, DiagLayer)
+                for prot_snref in self.protocol_snrefs
+            ])
+        else:
+            self._protocols = NamedItemList([
+                resolve_snref(prot_snref, diag_layer.protocols)
+                for prot_snref in self.protocol_snrefs
+            ])

odxtools/diagdatadictionaryspec.py

@@ -10,6 +10,7 @@ from .createsdgs import create_sdgs_from_et
 from .dataobjectproperty import DataObjectProperty
 from .dopbase import DopBase
 from .dtcdop import DtcDop
+from .dynamicendmarkerfield import DynamicEndmarkerField
 from .dynamiclengthfield import DynamicLengthField
 from .endofpdufield import EndOfPduField
 from .environmentdata import EnvironmentData
@@ -37,7 +38,7 @@ class DiagDataDictionarySpec:
     structures: NamedItemList[BasicStructure]
     static_fields: NamedItemList[StaticField]
     dynamic_length_fields: NamedItemList[DynamicLengthField]
-    #dynamic_endmarker_fields: NamedItemList[DynamicEndmarkerField]
+    dynamic_endmarker_fields: NamedItemList[DynamicEndmarkerField]
     end_of_pdu_fields: NamedItemList[EndOfPduField]
     muxs: NamedItemList[Multiplexer]
     env_datas: NamedItemList[EnvironmentData]
@@ -54,7 +55,7 @@ class DiagDataDictionarySpec:
                 self.structures,
                 self.static_fields,
                 self.dynamic_length_fields,
-                #self.dynamic_endmarker_fields,
+                self.dynamic_endmarker_fields,
                 self.end_of_pdu_fields,
                 self.muxs,
                 self.env_datas,
@@ -99,11 +100,10 @@ class DiagDataDictionarySpec:
             for dl_element in et_element.iterfind("DYNAMIC-LENGTH-FIELDS/DYNAMIC-LENGTH-FIELD")
         ]
 
-        # TODO: dynamic endmarker fields
-        #dynamic_endmarker_fields = [
-        #    DynamicEndmarkerField.from_et(dl_element, doc_frags)
-        #    for dl_element in et_element.iterfind("DYNAMIC-ENDMARKER-FIELDS/DYNAMIC-ENDMARKER-FIELD")
-        #]
+        dynamic_endmarker_fields = [
+            DynamicEndmarkerField.from_et(dl_element, doc_frags) for dl_element in
+            et_element.iterfind("DYNAMIC-ENDMARKER-FIELDS/DYNAMIC-ENDMARKER-FIELD")
+        ]
 
         end_of_pdu_fields = [
             EndOfPduField.from_et(eofp_element, doc_frags)
@@ -145,7 +145,7 @@ class DiagDataDictionarySpec:
             structures=NamedItemList(structures),
             static_fields=NamedItemList(static_fields),
             dynamic_length_fields=NamedItemList(dynamic_length_fields),
-            #dynamic_endmarker_fields=NamedItemList(dynamic_endmarker_fields),
+            dynamic_endmarker_fields=NamedItemList(dynamic_endmarker_fields),
             end_of_pdu_fields=NamedItemList(end_of_pdu_fields),
             muxs=NamedItemList(muxs),
             env_datas=NamedItemList(env_datas),
@@ -172,8 +172,8 @@ class DiagDataDictionarySpec:
             odxlinks.update(static_field._build_odxlinks())
         for dynamic_length_field in self.dynamic_length_fields:
             odxlinks.update(dynamic_length_field._build_odxlinks())
-        #for dynamic_endmarker_field in self.dynamic_endmarker_fields:
-        #    odxlinks.update(dynamic_endmarker_field._build_odxlinks())
+        for dynamic_endmarker_field in self.dynamic_endmarker_fields:
+            odxlinks.update(dynamic_endmarker_field._build_odxlinks())
         for end_of_pdu_field in self.end_of_pdu_fields:
             odxlinks.update(end_of_pdu_field._build_odxlinks())
         for mux in self.muxs:
@@ -204,8 +204,8 @@ class DiagDataDictionarySpec:
             static_field._resolve_odxlinks(odxlinks)
         for dynamic_length_field in self.dynamic_length_fields:
             dynamic_length_field._resolve_odxlinks(odxlinks)
-        #for dynamic_endmarker_field in self.dynamic_endmarker_fields:
-        #    dynamic_endmarker_field._resolve_odxlinks(odxlinks)
+        for dynamic_endmarker_field in self.dynamic_endmarker_fields:
+            dynamic_endmarker_field._resolve_odxlinks(odxlinks)
         for end_of_pdu_field in self.end_of_pdu_fields:
             end_of_pdu_field._resolve_odxlinks(odxlinks)
         for mux in self.muxs:
@@ -234,8 +234,8 @@ class DiagDataDictionarySpec:
             static_field._resolve_snrefs(diag_layer)
         for dynamic_length_field in self.dynamic_length_fields:
             dynamic_length_field._resolve_snrefs(diag_layer)
-        #for dynamic_endmarker_field in self.dynamic_endmarker_fields:
-        #    dynamic_endmarker_field._resolve_snrefs(diag_layer)
+        for dynamic_endmarker_field in self.dynamic_endmarker_fields:
+            dynamic_endmarker_field._resolve_snrefs(diag_layer)
         for end_of_pdu_field in self.end_of_pdu_fields:
             end_of_pdu_field._resolve_snrefs(diag_layer)
         for mux in self.muxs: