odxtools 6.6.1__py3-none-any.whl → 9.3.0__py3-none-any.whl

odxtools/dtcdop.py

@@ -1,9 +1,10 @@
 # SPDX-License-Identifier: MIT
-# from dataclasses import dataclass, field
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union, cast
+from typing import Any, Dict, List, Optional, Union, cast
 from xml.etree import ElementTree
 
+from typing_extensions import override
+
 from .compumethods.compumethod import CompuMethod
 from .compumethods.createanycompumethod import create_any_compu_method_from_et
 from .createanydiagcodedtype import create_any_diag_coded_type_from_et
@@ -12,15 +13,59 @@ from .diagcodedtype import DiagCodedType
 from .diagnostictroublecode import DiagnosticTroubleCode
 from .dopbase import DopBase
 from .encodestate import EncodeState
-from .exceptions import DecodeError, EncodeError, odxassert, odxrequire
+from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
 from .nameditemlist import NamedItemList
-from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import ParameterValue, odxstr_to_bool
 from .physicaltype import PhysicalType
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
+
+@dataclass
+class LinkedDtcDop:
+    not_inherited_dtc_snrefs: List[str]
+    dtc_dop_ref: OdxLinkRef
+
+    @property
+    def dtc_dop(self) -> "DtcDop":
+        return self._dtc_dop
+
+    @property
+    def short_name(self) -> str:
+        return self._dtc_dop.short_name
+
+    @property
+    def not_inherited_dtcs(self) -> NamedItemList[DiagnosticTroubleCode]:
+        return self._not_inherited_dtcs
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "LinkedDtcDop":
+        not_inherited_dtc_snrefs = [
+            odxrequire(el.get("SHORT-NAME"))
+            for el in et_element.iterfind("NOT-INHERITED-DTC-SNREFS/"
+                                          "NOT-INHERITED-DTC-SNREF")
+        ]
+
+        dtc_dop_ref = odxrequire(OdxLinkRef.from_et(et_element.find("DTC-DOP-REF"), doc_frags))
+
+        return LinkedDtcDop(
+            not_inherited_dtc_snrefs=not_inherited_dtc_snrefs, dtc_dop_ref=dtc_dop_ref)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        return {}
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._dtc_dop = odxlinks.resolve(self.dtc_dop_ref, DtcDop)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        dtc_dop = self._dtc_dop
+        not_inherited_dtcs = [
+            resolve_snref(ni_snref, dtc_dop.dtcs, DiagnosticTroubleCode)
+            for ni_snref in self.not_inherited_dtc_snrefs
+        ]
+
+        self._not_inherited_dtcs = NamedItemList(not_inherited_dtcs)
 
 
 @dataclass
@@ -31,9 +76,12 @@ class DtcDop(DopBase):
     physical_type: PhysicalType
     compu_method: CompuMethod
     dtcs_raw: List[Union[DiagnosticTroubleCode, OdxLinkRef]]
-    linked_dtc_dop_refs: List[OdxLinkRef]
+    linked_dtc_dops_raw: List[LinkedDtcDop]
     is_visible_raw: Optional[bool]
 
+    def __post_init__(self) -> None:
+        self._init_finished = False
+
     @staticmethod
     def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "DtcDop":
         """Reads a DTC-DOP."""
@@ -46,8 +94,8 @@ class DtcDop(DopBase):
         compu_method = create_any_compu_method_from_et(
             odxrequire(et_element.find("COMPU-METHOD")),
             doc_frags,
-            diag_coded_type.base_data_type,
-            physical_type.base_data_type,
+            internal_type=diag_coded_type.base_data_type,
+            physical_type=physical_type.base_data_type,
         )
         dtcs_raw: List[Union[DiagnosticTroubleCode, OdxLinkRef]] = []
         if (dtcs_elem := et_element.find("DTCS")) is not None:
@@ -57,12 +105,10 @@ class DtcDop(DopBase):
                 elif dtc_proxy_elem.tag == "DTC-REF":
                     dtcs_raw.append(OdxLinkRef.from_et(dtc_proxy_elem, doc_frags))
 
-        # TODO: NOT-INHERITED-DTC-SNREFS
-        linked_dtc_dop_refs = [
-            cast(OdxLinkRef, OdxLinkRef.from_et(dtc_ref_elem, doc_frags))
+        linked_dtc_dops_raw = [
+            LinkedDtcDop.from_et(dtc_ref_elem, doc_frags)
             for dtc_ref_elem in et_element.iterfind("LINKED-DTC-DOPS/"
-                                                    "LINKED-DTC-DOP/"
-                                                    "DTC-DOP-REF")
+                                                    "LINKED-DTC-DOP")
         ]
         is_visible_raw = odxstr_to_bool(et_element.get("IS-VISIBLE"))
 
@@ -71,7 +117,7 @@ class DtcDop(DopBase):
             physical_type=physical_type,
             compu_method=compu_method,
             dtcs_raw=dtcs_raw,
-            linked_dtc_dop_refs=linked_dtc_dop_refs,
+            linked_dtc_dops_raw=linked_dtc_dops_raw,
             is_visible_raw=is_visible_raw,
             **kwargs)
 
@@ -80,24 +126,27 @@ class DtcDop(DopBase):
         return self._dtcs
 
     @property
-    def is_visible(self) -> bool:
-        return self.is_visible_raw is True
+    def linked_dtc_dops(self) -> NamedItemList[LinkedDtcDop]:
+        return self._linked_dtc_dops
 
     @property
-    def linked_dtc_dops(self) -> NamedItemList["DtcDop"]:
-        return self._linked_dtc_dops
+    def is_visible(self) -> bool:
+        return self.is_visible_raw is True
 
+    @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
 
         int_trouble_code = self.diag_coded_type.decode_from_pdu(decode_state)
 
-        if self.compu_method.is_valid_internal_value(int_trouble_code):
-            trouble_code = self.compu_method.convert_internal_to_physical(int_trouble_code)
-        else:
+        if not self.compu_method.is_valid_internal_value(int_trouble_code):
             # TODO: How to prevent this?
-            raise DecodeError(
+            odxraise(
                 f"DTC-DOP {self.short_name} could not convert the coded value "
-                f" {repr(int_trouble_code)} to physical type {self.physical_type.base_data_type}.")
+                f" {repr(int_trouble_code)} to physical type {self.physical_type.base_data_type}.",
+                DecodeError)
+            return
+
+        trouble_code = self.compu_method.convert_internal_to_physical(int_trouble_code)
 
         assert isinstance(trouble_code, int)
 
@@ -110,12 +159,15 @@ class DtcDop(DopBase):
             return dtcs[0]
 
         # the DTC was not specified. This probably means that the
-        # diagnostic description file is incomplete. We do not bail
-        # out but we cannot provide an interpretation for it out of the
-        # box...
-        dtc = DiagnosticTroubleCode(
+        # diagnostic description file is incomplete.
+        odxraise(
+            f"Encountered DTC 0x{trouble_code:06x} which has not been defined "
+            f"by the database", DecodeError)
+
+        return DiagnosticTroubleCode(
             trouble_code=trouble_code,
             odx_id=cast(OdxLinkId, None),
+            oid=None,
             short_name=f'DTC_{trouble_code:06x}',
             long_name=None,
             description=None,
@@ -126,41 +178,70 @@ class DtcDop(DopBase):
             sdgs=[],
         )
 
-        return dtc
-
-    def convert_physical_to_bytes(self, physical_value: ParameterValue, encode_state: EncodeState,
-                                  bit_position: int) -> bytes:
-        if isinstance(physical_value, DiagnosticTroubleCode):
-            trouble_code = physical_value.trouble_code
-        elif isinstance(physical_value, int):
+    def convert_to_numerical_trouble_code(self, dtc_value: ParameterValue) -> int:
+        if isinstance(dtc_value, DiagnosticTroubleCode):
+            return dtc_value.trouble_code
+        elif isinstance(dtc_value, int):
             # assume that physical value is the trouble_code
-            trouble_code = physical_value
-        elif isinstance(physical_value, str):
+            return dtc_value
+        elif isinstance(dtc_value, str):
             # assume that physical value is the short_name
-            dtcs = [dtc for dtc in self.dtcs if dtc.short_name == physical_value]
-            odxassert(len(dtcs) == 1)
-            trouble_code = dtcs[0].trouble_code
+            dtcs = [dtc for dtc in self.dtcs if dtc.short_name == dtc_value]
+            if len(dtcs) != 1:
+                odxraise(f"No DTC named {dtc_value} found for DTC-DOP "
+                         f"{self.short_name}.", EncodeError)
+                return cast(int, None)
+
+            return dtcs[0].trouble_code
         else:
-            raise EncodeError(f"The DTC-DOP {self.short_name} expected a"
-                              f" DiagnosticTroubleCode but got {physical_value!r}.")
+            odxraise(
+                f"The DTC-DOP {self.short_name} expected a"
+                f" diagnostic trouble code but got {type(dtc_value).__name__}", EncodeError)
+            return cast(int, None)
+
+    @override
+    def encode_into_pdu(self, physical_value: Optional[ParameterValue],
+                        encode_state: EncodeState) -> None:
+        if physical_value is None:
+            odxraise(f"No DTC specified", EncodeError)
+            return
+
+        trouble_code = self.convert_to_numerical_trouble_code(physical_value)
 
-        internal_trouble_code = self.compu_method.convert_physical_to_internal(trouble_code)
+        internal_trouble_code = int(self.compu_method.convert_physical_to_internal(trouble_code))
 
-        return self.diag_coded_type.convert_internal_to_bytes(
-            internal_trouble_code, encode_state=encode_state, bit_position=bit_position)
+        found = False
+        for dtc in self.dtcs:
+            if internal_trouble_code == dtc.trouble_code:
+                found = True
+                break
+
+        if not found:
+            odxraise(
+                f"Unknown diagnostic trouble code {physical_value!r} "
+                f"(0x{internal_trouble_code: 06x}) specified", EncodeError)
+
+        self.diag_coded_type.encode_into_pdu(internal_trouble_code, encode_state)
 
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         odxlinks = super()._build_odxlinks()
 
+        odxlinks.update(self.compu_method._build_odxlinks())
+
         for dtc_proxy in self.dtcs_raw:
             if isinstance(dtc_proxy, DiagnosticTroubleCode):
                 odxlinks.update(dtc_proxy._build_odxlinks())
 
+        for linked_dtc_dop in self.linked_dtc_dops_raw:
+            odxlinks.update(linked_dtc_dop._build_odxlinks())
+
         return odxlinks
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
         super()._resolve_odxlinks(odxlinks)
 
+        self.compu_method._resolve_odxlinks(odxlinks)
+
         self._dtcs = NamedItemList[DiagnosticTroubleCode]()
         for dtc_proxy in self.dtcs_raw:
             if isinstance(dtc_proxy, DiagnosticTroubleCode):
@@ -170,12 +251,51 @@ class DtcDop(DopBase):
                 dtc = odxlinks.resolve(dtc_proxy, DiagnosticTroubleCode)
                 self._dtcs.append(dtc)
 
-        linked_dtc_dops = [odxlinks.resolve(x, DtcDop) for x in self.linked_dtc_dop_refs]
-        self._linked_dtc_dops = NamedItemList(linked_dtc_dops)
+        for linked_dtc_dop in self.linked_dtc_dops_raw:
+            linked_dtc_dop._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        # hack to avoid initializing the DtcDop object multiple
+        # times. This is required, because the linked DTC DOP feature
+        # requires the "parent" DTC DOPs to be fully initialized but
+        # the standard does not define a formal ordering of DTC DOPs.
+        if self._init_finished:
+            return
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
+        self._init_finished = True
+
+        super()._resolve_snrefs(context)
+
+        self.compu_method._resolve_snrefs(context)
 
         for dtc_proxy in self.dtcs_raw:
             if isinstance(dtc_proxy, DiagnosticTroubleCode):
-                dtc_proxy._resolve_snrefs(diag_layer)
+                dtc_proxy._resolve_snrefs(context)
+
+        for linked_dtc_dop in self.linked_dtc_dops_raw:
+            linked_dtc_dop._resolve_snrefs(context)
+
+        # add the inherited DTCs from linked DTC DOPs. Note that this
+        # requires that there are no cycles in the "link-hierarchy"
+        dtc_short_names = {dtc.short_name for dtc in self._dtcs}
+        for linked_dtc_dop in self.linked_dtc_dops_raw:
+            linked_dtc_dop.dtc_dop._resolve_snrefs(context)
+
+            for dtc in linked_dtc_dop.dtc_dop.dtcs:
+                if dtc.short_name in dtc_short_names:
+                    # we already have a DTC with that name. Since we
+                    # are not supposed to overwrite the local DTCs, we
+                    # skip processing this one. TODO: Are inheritance
+                    # conflicts for DTCs allowed?
+                    continue
+
+                if dtc.short_name in linked_dtc_dop.not_inherited_dtc_snrefs:
+                    # DTC is explicitly not inherited
+                    continue
+
+                self._dtcs.append(dtc)
+                dtc_short_names.add(dtc.short_name)
+
+        # at this place, the linked DTC DOPs exhibit .short_name, so
+        # we can create a NamedItemList...
+        self._linked_dtc_dops = NamedItemList(self.linked_dtc_dops_raw)

odxtools/dynamicendmarkerfield.py

@@ -0,0 +1,134 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Sequence
+from xml.etree import ElementTree
+
+from typing_extensions import override
+
+from .dataobjectproperty import DataObjectProperty
+from .decodestate import DecodeState
+from .dynenddopref import DynEndDopRef
+from .encodestate import EncodeState
+from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequire
+from .field import Field
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
+from .odxtypes import AtomicOdxType, ParameterValue
+from .snrefcontext import SnRefContext
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class DynamicEndmarkerField(Field):
+    """Array of a structure with variable length determined by a termination sequence"""
+
+    dyn_end_dop_ref: DynEndDopRef
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DynamicEndmarkerField":
+        kwargs = dataclass_fields_asdict(Field.from_et(et_element, doc_frags))
+
+        # ODX 2.0 uses DATA-OBJECT-PROP-REF
+        # ODX 2.2 uses DYN-END-DOP-REF
+        dop_ref = et_element.find("DYN-END-DOP-REF") or et_element.find("DATA-OBJECT-PROP-REF")
+        dyn_end_dop_ref = DynEndDopRef.from_et(odxrequire(dop_ref), doc_frags)
+
+        return DynamicEndmarkerField(dyn_end_dop_ref=dyn_end_dop_ref, **kwargs)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        odxlinks = super()._build_odxlinks()
+        return odxlinks
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        super()._resolve_odxlinks(odxlinks)
+
+        self._dyn_end_dop = odxlinks.resolve(self.dyn_end_dop_ref, DataObjectProperty)
+
+        tv_string = self.dyn_end_dop_ref.termination_value_raw
+        tv_physical = self._dyn_end_dop.diag_coded_type.base_data_type.from_string(tv_string)
+
+        self._termination_value = tv_physical
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+
+    @property
+    def dyn_end_dop(self) -> DataObjectProperty:
+        return self._dyn_end_dop
+
+    @property
+    def termination_value(self) -> AtomicOdxType:
+        return self._termination_value
+
+    @override
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
+
+        odxassert(encode_state.cursor_bit_position == 0,
+                  "No bit position can be specified for dynamic endmarker fields!")
+        if not isinstance(physical_value, Sequence):
+            odxraise(
+                f"Expected a sequence of values for dynamic endmarker field {self.short_name}, "
+                f"got {type(physical_value).__name__}", EncodeError)
+            return
+
+        orig_is_end_of_pdu = encode_state.is_end_of_pdu
+        encode_state.is_end_of_pdu = False
+        for i, item in enumerate(physical_value):
+            if i == len(physical_value) - 1:
+                encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+            self.structure.encode_into_pdu(item, encode_state)
+        encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+        if not encode_state.is_end_of_pdu:
+            # only add an endmarker if we are not at the end of the
+            # PDU. note that since section 7.3.6.10.5 of the MCD-2
+            # specification states that the data used by the endmarker
+            # ought to be considered to be not consumed (why?!), we
+            # need to keep the cursor where it is before adding the
+            # endmarker. (we still consider its bits to be used
+            # "used", in order to produce a warning if it is attempted
+            # to be overridden.)
+            tmp_cursor = encode_state.cursor_byte_position
+            self.dyn_end_dop.encode_into_pdu(self.termination_value, encode_state)
+            encode_state.cursor_byte_position = tmp_cursor
+
+    @override
+    def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
+
+        odxassert(decode_state.cursor_bit_position == 0,
+                  "No bit position can be specified for dynamic endmarker fields!")
+
+        orig_origin = decode_state.origin_byte_position
+        decode_state.origin_byte_position = decode_state.cursor_byte_position
+
+        result: List[ParameterValue] = []
+        while True:
+            # check if we're at the end of the PDU
+            if decode_state.cursor_byte_position == len(decode_state.coded_message):
+                break
+
+            # check if the cursor currently points to a termination
+            # value
+            tmp_cursor = decode_state.cursor_byte_position
+            try:
+                tv_candidate = self.dyn_end_dop.decode_from_pdu(decode_state)
+                if tv_candidate == self.termination_value:
+                    # note that section 7.3.6.10.5 of the MCD-2
+                    # specification states that the bytes occupied by
+                    # the endmarker ought to be considered to be not
+                    # consumed (why?!), i.e., we need to keep the
+                    # cursor where it is before adding the
+                    # endmarker. (we still consider its to be used
+                    # "used", though.)
+                    decode_state.cursor_byte_position = tmp_cursor
+                    break
+            except DecodeError:
+                pass
+            decode_state.cursor_byte_position = tmp_cursor
+
+            result.append(self.structure.decode_from_pdu(decode_state))
+
+        decode_state.origin_byte_position = orig_origin
+
+        return result

odxtools/dynamiclengthfield.py

@@ -1,8 +1,10 @@
 # SPDX-License-Identifier: MIT
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import Any, Dict, List, Sequence
 from xml.etree import ElementTree
 
+from typing_extensions import override
+
 from .decodestate import DecodeState
 from .determinenumberofitems import DetermineNumberOfItems
 from .encodestate import EncodeState
@@ -10,11 +12,9 @@ from .exceptions import DecodeError, EncodeError, odxassert, odxraise, odxrequir
 from .field import Field
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId
 from .odxtypes import ParameterValue
+from .snrefcontext import SnRefContext
 from .utils import dataclass_fields_asdict
 
-if TYPE_CHECKING:
-    from .diaglayer import DiagLayer
-
 
 @dataclass
 class DynamicLengthField(Field):
@@ -43,55 +43,60 @@ class DynamicLengthField(Field):
         super()._resolve_odxlinks(odxlinks)
         self.determine_number_of_items._resolve_odxlinks(odxlinks)
 
-    def _resolve_snrefs(self, diag_layer: "DiagLayer") -> None:
-        super()._resolve_snrefs(diag_layer)
-        self.determine_number_of_items._resolve_snrefs(diag_layer)
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        super()._resolve_snrefs(context)
+        self.determine_number_of_items._resolve_snrefs(context)
+
+    @override
+    def encode_into_pdu(self, physical_value: ParameterValue, encode_state: EncodeState) -> None:
 
-    def convert_physical_to_bytes(
-        self,
-        physical_value: ParameterValue,
-        encode_state: EncodeState,
-        bit_position: int = 0,
-    ) -> bytes:
+        odxassert(encode_state.cursor_bit_position == 0,
+                  "No bit position can be specified for dynamic length fields!")
 
-        odxassert(bit_position == 0, "No bit position can be specified for dynamic length fields!")
-        if not isinstance(physical_value, list):
+        if not isinstance(physical_value, Sequence):
             odxraise(
                 f"Expected a list of values for dynamic length field {self.short_name}, "
                 f"got {type(physical_value)}", EncodeError)
 
+        # move the origin to the cursor position
+        orig_origin = encode_state.origin_byte_position
+        encode_state.origin_byte_position = encode_state.cursor_byte_position
+
         det_num_items = self.determine_number_of_items
-        field_len = det_num_items.dop.convert_physical_to_bytes(
-            len(physical_value), encode_state, det_num_items.bit_position or 0)
-
-        # hack to emplace the length specifier at the correct location
-        tmp = encode_state.coded_message
-        encode_state.coded_message = bytearray()
-        encode_state.emplace_atomic_value(field_len, self.short_name + ".num_items",
-                                          det_num_items.byte_position)
-        result = encode_state.coded_message
-        encode_state.coded_message = tmp
-
-        # if required, add padding between the length specifier and
-        # the first item
-        if len(result) < self.offset:
-            result.extend([0] * (self.offset - len(result)))
-        elif len(result) > self.offset:
+        encode_state.cursor_bit_position = self.determine_number_of_items.bit_position or 0
+        encode_state.cursor_byte_position = encode_state.origin_byte_position + det_num_items.byte_position
+        det_num_items.dop.encode_into_pdu(len(physical_value), encode_state)
+
+        if encode_state.cursor_byte_position - encode_state.origin_byte_position > self.offset:
             odxraise(f"The length specifier of field {self.short_name} overlaps "
-                     f"with the first item!")
+                     f"with its first item!")
 
-        for value in physical_value:
-            result += self.structure.convert_physical_to_bytes(value, encode_state)
+        encode_state.cursor_byte_position = encode_state.origin_byte_position + self.offset
+        encode_state.cursor_bit_position = 0
 
-        return result
+        orig_is_end_of_pdu = encode_state.is_end_of_pdu
+        encode_state.is_end_of_pdu = False
+        for i, value in enumerate(physical_value):
+            if i == len(physical_value) - 1:
+                encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+            self.structure.encode_into_pdu(value, encode_state)
+        encode_state.is_end_of_pdu = orig_is_end_of_pdu
+
+        # ensure the correct message size if the field is empty
+        if len(physical_value) == 0:
+            encode_state.emplace_bytes(b"")
 
+        # move cursor and origin positions
+        encode_state.origin_byte_position = orig_origin
+
+    @override
     def decode_from_pdu(self, decode_state: DecodeState) -> ParameterValue:
 
         odxassert(decode_state.cursor_bit_position == 0,
                   "No bit position can be specified for dynamic length fields!")
 
         orig_origin = decode_state.origin_byte_position
-        orig_cursor = decode_state.cursor_byte_position
 
         det_num_items = self.determine_number_of_items
         decode_state.origin_byte_position = decode_state.cursor_byte_position
@@ -99,6 +104,7 @@ class DynamicLengthField(Field):
         decode_state.cursor_bit_position = det_num_items.bit_position or 0
 
         n = det_num_items.dop.decode_from_pdu(decode_state)
+        result: List[ParameterValue] = []
 
         if not isinstance(n, int):
             odxraise(f"Number of items specified by a dynamic length field {self.short_name} "
@@ -107,13 +113,12 @@ class DynamicLengthField(Field):
             odxraise(
                 f"Number of items specified by a dynamic length field {self.short_name} "
                 f"must be positive (is: {n})", DecodeError)
-        else:
-            decode_state.cursor_byte_position = decode_state.origin_byte_position + self.offset
-            result: List[ParameterValue] = []
-            for _ in range(n):
-                result.append(self.structure.decode_from_pdu(decode_state))
+            n = 0
+
+        decode_state.cursor_byte_position = decode_state.origin_byte_position + self.offset
+        for _ in range(n):
+            result.append(self.structure.decode_from_pdu(decode_state))
 
         decode_state.origin_byte_position = orig_origin
-        decode_state.cursor_byte_position = max(orig_cursor, decode_state.cursor_byte_position)
 
         return result