odxtools 7.2.0__py3-none-any.whl → 7.4.0__py3-none-any.whl

odxtools/multiplexercase.py

@@ -3,13 +3,13 @@ from dataclasses import dataclass
 from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from .basicstructure import BasicStructure
 from .compumethods.limit import Limit
 from .element import NamedElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .odxtypes import AtomicOdxType, DataType
 from .snrefcontext import SnRefContext
+from .structure import Structure
 from .utils import dataclass_fields_asdict
 
 
@@ -23,7 +23,7 @@ class MultiplexerCase(NamedElement):
     upper_limit: Limit
 
     def __post_init__(self) -> None:
-        self._structure: BasicStructure
+        self._structure: Optional[Structure]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
@@ -62,8 +62,9 @@ class MultiplexerCase(NamedElement):
 
     def _mux_case_resolve_odxlinks(self, odxlinks: OdxLinkDatabase, *,
                                    key_physical_type: DataType) -> None:
+        self._structure = None
         if self.structure_ref:
-            self._structure = odxlinks.resolve(self.structure_ref)
+            self._structure = odxlinks.resolve(self.structure_ref, Structure)
 
         self.lower_limit.set_value_type(key_physical_type)
         self.upper_limit.set_value_type(key_physical_type)
@@ -71,12 +72,12 @@ class MultiplexerCase(NamedElement):
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         if self.structure_snref:
             ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
-            self._structure = resolve_snref(self.structure_snref, ddds.structures, BasicStructure)
+            self._structure = resolve_snref(self.structure_snref, ddds.structures, Structure)
 
     def applies(self, value: AtomicOdxType) -> bool:
         return self.lower_limit.complies_to_lower(value) \
             and self.upper_limit.complies_to_upper(value)
 
     @property
-    def structure(self) -> BasicStructure:
+    def structure(self) -> Optional[Structure]:
         return self._structure

odxtools/multiplexerdefaultcase.py

@@ -3,11 +3,11 @@ from dataclasses import dataclass
 from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
-from .basicstructure import BasicStructure
 from .element import NamedElement
 from .exceptions import odxrequire
 from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
 from .snrefcontext import SnRefContext
+from .structure import Structure
 from .utils import dataclass_fields_asdict
 
 
@@ -18,12 +18,12 @@ class MultiplexerDefaultCase(NamedElement):
     structure_snref: Optional[str]
 
     def __post_init__(self) -> None:
-        self._structure: BasicStructure
+        self._structure: Optional[Structure]
 
     @staticmethod
     def from_et(et_element: ElementTree.Element,
                 doc_frags: List[OdxDocFragment]) -> "MultiplexerDefaultCase":
-        """Reads a Default Case for a Multiplexer."""
+        """Reads a default case for a multiplexer."""
         kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
 
         structure_ref = OdxLinkRef.from_et(et_element.find("STRUCTURE-REF"), doc_frags)
@@ -38,14 +38,15 @@ class MultiplexerDefaultCase(NamedElement):
         return {}
 
     def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._structure = None
         if self.structure_ref is not None:
-            self._structure = odxlinks.resolve(self.structure_ref)
+            self._structure = odxlinks.resolve(self.structure_ref, Structure)
 
     def _resolve_snrefs(self, context: SnRefContext) -> None:
         if self.structure_snref:
             ddds = odxrequire(context.diag_layer).diag_data_dictionary_spec
-            self._structure = resolve_snref(self.structure_snref, ddds.structures, BasicStructure)
+            self._structure = resolve_snref(self.structure_snref, ddds.structures, Structure)
 
     @property
-    def structure(self) -> BasicStructure:
+    def structure(self) -> Optional[Structure]:
         return self._structure

odxtools/odxlink.py

@@ -4,30 +4,14 @@ from dataclasses import dataclass
 from typing import Any, Dict, Iterable, List, Optional, Type, TypeVar, overload
 from xml.etree import ElementTree
 
-from .exceptions import OdxWarning, odxassert, odxraise
+from .exceptions import OdxWarning, odxassert, odxraise, odxrequire
 from .nameditemlist import OdxNamed, TNamed
 
 
 @dataclass(frozen=True)
 class OdxDocFragment:
     doc_name: str
-    doc_type: Optional[str]
-
-    def __eq__(self, other: Any) -> bool:
-        if other is None:
-            # if the other document fragment is not specified, we
-            # treat it as a wildcard...
-            return True
-
-        if not isinstance(other, OdxDocFragment):
-            return False
-
-        # the ODX spec says that the doctype can be ignored...
-        return self.doc_name == other.doc_name
-
-    def __hash__(self) -> int:
-        # only the document name is relevant for the hash value
-        return hash(self.doc_name) + hash(self.doc_type)
+    doc_type: str
 
 
 @dataclass(frozen=True)
@@ -59,10 +43,12 @@ class OdxLinkId:
         if not isinstance(other, OdxLinkId):
             return False
 
-        # we do take the document fragment into consideration here, because
-        # document fragments are handled using separate sub-databases,
-        # i.e. the same OdxId object can be put into all of them.
-        return self.local_id == other.local_id
+        # if the local ID is different, the whole id is different
+        if self.local_id != other.local_id:
+            return False
+
+        # the document fragments must be identical for the IDs to be identical
+        return self.doc_fragments == other.doc_fragments
 
     def __str__(self) -> str:
         return f"OdxLinkId('{self.local_id}')"
@@ -120,6 +106,7 @@ class OdxLinkRef:
 
         id_ref = et.attrib.get("ID-REF")
         if id_ref is None:
+            odxraise(f"Tag {et.tag} is not a ODXLINK reference")
             return None
 
         doc_ref = et.attrib.get("DOCREF")
@@ -133,7 +120,7 @@ class OdxLinkRef:
         # reference, use it, else use the document fragment containing
         # the reference.
         if doc_ref is not None:
-            doc_frags = [OdxDocFragment(doc_ref, doc_type)]
+            doc_frags = [OdxDocFragment(doc_ref, odxrequire(doc_type))]
         else:
             doc_frags = source_doc_frags
 
@@ -147,32 +134,19 @@ class OdxLinkRef:
     def __str__(self) -> str:
         return f"OdxLinkRef('{self.ref_id}')"
 
-    def __contains__(self, odx_id: OdxLinkId) -> bool:
-        """
-        Returns true iff a given OdxLinkId object is referenced.
-        """
-
-        # we must reference at to at least of the ID's document
-        # fragments
-        if not any(ref_doc in odx_id.doc_fragments for ref_doc in self.ref_docs):
-            return False
-
-        # the local ID of the reference and the object ID must match
-        return odx_id.local_id == self.ref_id
-
 
 T = TypeVar("T")
 
 
 class OdxLinkDatabase:
     """
-    A database holding all objects which ehibit OdxLinkIds
+    A database holding all objects which exhibit OdxLinkIds
 
-    This can resolve references to such.
+    This can resolve ODXLINK references.
     """
 
     def __init__(self) -> None:
-        self._db: Dict[OdxDocFragment, Dict[OdxLinkId, Any]] = {}
+        self._db: Dict[OdxDocFragment, Dict[str, Any]] = {}
 
     @overload
     def resolve(self, ref: OdxLinkRef, expected_type: None = None) -> Any:
@@ -189,13 +163,12 @@ class OdxLinkDatabase:
         If the database does not contain any object which is referred to, a
         KeyError exception is raised.
         """
-        odx_id = OdxLinkId(ref.ref_id, ref.ref_docs)
         for ref_frag in reversed(ref.ref_docs):
             doc_frag_db = self._db.get(ref_frag)
             if doc_frag_db is None:
                 # No object featured by the database uses the document
                 # fragment mentioned by the reference. This should not
-                # happen for correct databases...
+                # happen for correct ODX databases...
                 warnings.warn(
                     f"Warning: Unknown document fragment {ref_frag} "
                     f"when resolving reference {ref}",
@@ -204,8 +177,9 @@ class OdxLinkDatabase:
                 )
                 continue
 
-            obj = doc_frag_db.get(odx_id)
-            if obj is not None:
+            # locate an object exhibiting with the referenced local ID
+            # in the ID database for the document fragment
+            if (obj := doc_frag_db.get(ref.ref_id)) is not None:
                 if expected_type is not None:
                     odxassert(isinstance(obj, expected_type))
 
@@ -234,7 +208,6 @@ class OdxLinkDatabase:
         is returned.
         """
 
-        odx_id = OdxLinkId(ref.ref_id, ref.ref_docs)
         for ref_frag in reversed(ref.ref_docs):
             doc_frag_db = self._db.get(ref_frag)
             if doc_frag_db is None:
@@ -249,8 +222,7 @@ class OdxLinkDatabase:
                 )
                 continue
 
-            obj = doc_frag_db.get(odx_id)
-            if obj is not None:
+            if (obj := doc_frag_db.get(ref.ref_id)) is not None:
                 if expected_type is not None:
                     odxassert(isinstance(obj, expected_type))
 
@@ -272,7 +244,7 @@ class OdxLinkDatabase:
                 if doc_frag not in self._db:
                     self._db[doc_frag] = {}
 
-                self._db[doc_frag][odx_id] = obj
+                self._db[doc_frag][odx_id.local_id] = obj
 
 
 @overload

odxtools/odxtypes.py

@@ -235,7 +235,7 @@ class DataType(Enum):
         expected_type = self.python_type
         if isinstance(value, expected_type):
             return True
-        elif expected_type == float and isinstance(value, (int, float)):
+        elif expected_type is float and isinstance(value, (int, float)):
             return True
         elif self == DataType.A_BYTEFIELD and isinstance(value, (bytearray, bytes)):
             return True

odxtools/parameterinfo.py

@@ -108,8 +108,8 @@ def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False)
             of.write(f"multiplexer; choices:\n")
             for mux_case in dop.cases:
                 of.write(f"  ({repr(mux_case.short_name)}, {{\n")
-                of.write(
-                    textwrap.indent(parameter_info(mux_case.structure.parameters, True), "    "))
+                if (struc := mux_case.structure) is not None:
+                    of.write(textwrap.indent(parameter_info(struc.parameters, True), "    "))
                 of.write(f"   }})\n")
             continue
 

odxtools/parameters/nrcconstparameter.py

@@ -1,7 +1,6 @@
 # SPDX-License-Identifier: MIT
-import warnings
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, cast
+from typing import Any, Dict, List, Optional
 from xml.etree import ElementTree
 
 from typing_extensions import override
@@ -10,7 +9,7 @@ from ..createanydiagcodedtype import create_any_diag_coded_type_from_et
 from ..decodestate import DecodeState
 from ..diagcodedtype import DiagCodedType
 from ..encodestate import EncodeState
-from ..exceptions import DecodeError, EncodeError, odxraise, odxrequire
+from ..exceptions import DecodeMismatch, EncodeError, odxraise, odxrequire
 from ..odxlink import OdxDocFragment, OdxLinkId
 from ..odxtypes import AtomicOdxType, DataType, ParameterValue
 from ..utils import dataclass_fields_asdict
@@ -19,7 +18,8 @@ from .parameter import Parameter, ParameterType
 
 @dataclass
 class NrcConstParameter(Parameter):
-    """A param of type NRC-CONST defines a set of values to be matched for a negative response to apply.
+    """A parameter of type NRC-CONST defines a set of values to be
+    matched for a negative response object to apply
 
     The behaviour of NRC-CONST parameters is similar to CODED-CONST
     parameters in that they allow to specify which coding objects
@@ -88,49 +88,40 @@ class NrcConstParameter(Parameter):
     @override
     def _encode_positioned_into_pdu(self, physical_value: Optional[ParameterValue],
                                     encode_state: EncodeState) -> None:
-        coded_value: ParameterValue
+        # NRC-CONST parameters are not encoding any value on its
+        # own. instead, it is supposed to overlap with a value
+        # parameter.
         if physical_value is not None:
-            if physical_value not in self.coded_values:
-                odxraise(
-                    f"The value of parameter '{self.short_name}' must "
-                    f" be one of {self.coded_values} (is: {physical_value!r})", EncodeError)
-                coded_value = self.coded_values[0]
-            else:
-                coded_value = physical_value
-        else:
-            # If the user did not select a value, the value of the
-            # this parameter is set by another parameter which
-            # overlaps with it. We thus just move the cursor.
-            bit_pos = encode_state.cursor_bit_position
-            bit_len = self.diag_coded_type.get_static_bit_length()
-
-            if bit_len is None:
-                odxraise("The diag coded type of NRC-CONST parameters must "
-                         "exhibit a static size")
-                return
-
-            encode_state.cursor_byte_position += (bit_pos + bit_len + 7) // 8
-            encode_state.cursor_bit_position = 0
+            odxraise("The value of NRC-CONST parameters cannot be set directly!", EncodeError)
+
+        # TODO (?): extract the parameter and check if it is one of
+        # the values of self.coded_values. if not, throw an
+        # EncodeMismatch exception! This is probably a bad idea
+        # because the parameter which determines the value of the
+        # NRC-CONST might possibly be specified after the NRC-CONST.
+
+        # move the cursor forward by the size of the parameter
+        bit_pos = encode_state.cursor_bit_position
+        bit_len = self.diag_coded_type.get_static_bit_length()
+
+        if bit_len is None:
+            odxraise("The diag coded type of NRC-CONST parameters must "
+                     "exhibit a static size")
             return
 
-        self.diag_coded_type.encode_into_pdu(cast(AtomicOdxType, coded_value), encode_state)
+        encode_state.cursor_byte_position += (bit_pos + bit_len + 7) // 8
+        encode_state.cursor_bit_position = 0
+
+        encode_state.emplace_bytes(b'', self.short_name)
 
     @override
     def _decode_positioned_from_pdu(self, decode_state: DecodeState) -> AtomicOdxType:
-        # Extract coded values
+        # Extract coded value
         coded_value = self.diag_coded_type.decode_from_pdu(decode_state)
 
         # Check if the coded value in the message is correct.
         if coded_value not in self.coded_values:
-            warnings.warn(
-                f"Coded constant parameter does not match! "
-                f"The parameter {self.short_name} expected a coded "
-                f"value in {str(self.coded_values)} but got {str(coded_value)} "
-                f"at byte position {decode_state.cursor_byte_position} "
-                f"in coded message {decode_state.coded_message.hex()}.",
-                DecodeError,
-                stacklevel=1,
-            )
+            raise DecodeMismatch(f"NRC-CONST parameter {self.short_name} does not apply")
 
         return coded_value
 

odxtools/parameters/systemparameter.py

@@ -26,7 +26,7 @@ class SystemParameter(ParameterWithDOP):
 
         kwargs = dataclass_fields_asdict(ParameterWithDOP.from_et(et_element, doc_frags))
 
-        sysparam = odxrequire(et_element.findtext("SYSPARAM"))
+        sysparam = odxrequire(et_element.get("SYSPARAM"))
 
         return SystemParameter(sysparam=sysparam, **kwargs)
 

odxtools/parameters/tablekeyparameter.py

@@ -99,13 +99,20 @@ class TableKeyParameter(Parameter):
 
         if self.table_snref is not None:
             tables = odxrequire(context.diag_layer).diag_data_dictionary_spec.tables
-            self._table = resolve_snref(self.table_snref, tables, Table)
+            if TYPE_CHECKING:
+                self._table = resolve_snref(self.table_snref, tables, Table)
+            else:
+                self._table = resolve_snref(self.table_snref, tables)
         if self.table_row_snref is not None:
             # make sure that we know the table to which the table row
             # SNREF is relative to.
-            table = odxrequire(self._table,
-                               "If a table-row is referenced, a table must also be referenced.")
-            self._table_row = resolve_snref(self.table_row_snref, table.table_rows, TableRow)
+            table = odxrequire(
+                self._table, "If a table row is referenced via short name, a table must "
+                "be referenced as well")
+            if TYPE_CHECKING:
+                self._table_row = resolve_snref(self.table_row_snref, table.table_rows, TableRow)
+            else:
+                self._table_row = resolve_snref(self.table_row_snref, table.table_rows)
 
     @property
     def table(self) -> "Table":

odxtools/servicebinner.py

@@ -91,7 +91,7 @@ class ServiceBinner:
         """
         result = StringIO()
         result.write("[ ")
-        result.write(", ".join([f"0x{x}" for x in self._service_groups if x is not None]))
+        result.write(", ".join([f"0x{x:x}" for x in self._service_groups if x is not None]))
         result.write(" ]")
 
         return result.getvalue()

odxtools/specialdatagroup.py

@@ -51,7 +51,7 @@ class SpecialDataGroup:
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         result = {}
 
-        if self.sdg_caption is not None:
+        if self.sdg_caption_ref is None and self.sdg_caption is not None:
             result.update(self.sdg_caption._build_odxlinks())
 
         for val in self.values:

odxtools/swvariable.py

@@ -0,0 +1,21 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import List, Optional
+from xml.etree import ElementTree
+
+from .element import NamedElement
+from .odxlink import OdxDocFragment
+from .utils import dataclass_fields_asdict
+
+
+@dataclass
+class SwVariable(NamedElement):
+    origin: Optional[str]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element, doc_frags: List[OdxDocFragment]) -> "SwVariable":
+        kwargs = dataclass_fields_asdict(NamedElement.from_et(et_element, doc_frags))
+
+        origin = et_element.findtext("ORIGIN")
+
+        return SwVariable(origin=origin, **kwargs)

odxtools/templates/macros/printComparam.xml.jinja2

@@ -44,7 +44,9 @@
          {{make_xml_attrib("DISPLAY-LEVEL", cp.display_level)}}{#- #}
           CPUSAGE="{{cp.cpusage.value}}">
   {{ peid.printElementIdSubtags(cp)|indent(1) }}
-  <PHYSICAL-DEFAULT-VALUE>{{cp.physical_default_value}}</PHYSICAL-DEFAULT-VALUE>
+  {%- if cp.physical_default_value is not none %}
+  <PHYSICAL-DEFAULT-VALUE>{{cp.physical_default_value | e}}</PHYSICAL-DEFAULT-VALUE>
+  {%- endif %}
  <DATA-OBJECT-PROP-REF ID-REF="{{cp.dop_ref.ref_id}}" />
 </COMPARAM>
 {%- endmacro %}
@@ -61,7 +63,7 @@
  {%- for sub_cp in cp.subparams %}
  {{- printAnyComparam(sub_cp) | indent(1, first=True) }}
  {%- endfor %}
- {%- if  cp.physical_default_value is not none %}
+ {%- if cp.physical_default_value is not none %}
  {{ printComplexValue(cp.physical_default_value, "COMPLEX-PHYSICAL-DEFAULT-VALUE") | indent(1) }}
  {%- endif %}
 </COMPLEX-COMPARAM>

odxtools/templates/macros/printCompuMethod.xml.jinja2

@@ -18,14 +18,7 @@
 {%- if limit_obj.value_raw is none %}
   {#- #}/>
 {%- else %}
-  {#- #}>
-  {%- if hasattr(limit_obj._value, 'hex') -%}
-  {#- bytes or bytarray limit #}
-  {{- limit_obj._value.hex().upper() }}
-  {%- else -%}
-  {{- limit_obj._value }}
-  {%- endif -%}
-</{{tag_name}}>
+  {#- #}>{{- limit_obj.value_raw }}</{{tag_name}}>
 {%- endif -%}
 {%- endif -%}
 {%- endmacro -%}

odxtools/templates/macros/printDiagVariable.xml.jinja2

@@ -0,0 +1,66 @@
+{#- -*- mode: sgml; tab-width: 2; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+{%- import('macros/printElementId.xml.jinja2') as peid %}
+{%- import('macros/printAdminData.xml.jinja2') as pad %}
+{%- import('macros/printDescription.xml.jinja2') as pd %}
+
+{%- macro printDiagVariable(diag_var) -%}
+<DIAG-VARIABLE>
+  {{ peid.printElementIdSubtags(diag_variable)|indent(2) }}
+  {%- if diag_variable.admin_data is not none %}
+  {{ pad.printAdminData(diag_variable.admin_data)|indent(2) }}
+  {%- endif %}
+  <VARIABLE-GROUP-REF ID-REF="{{ diag_var.ref_id }}" />
+  {%- if diag_variable.sw_variables %}
+  <SW-VARIABLES>
+    {%- for sw_var in diag_variable.sw_variables %}
+    <SW-VARIABLE>
+      {{ peid.printElementIdSubtags(sw_var)|indent(6) }}
+      {%- if sw_var.origin is not none %}
+      <ORIGIN>{{ sw_var.origin }}</ORIGIN>
+      {%- endif %}
+    </SW-VARIABLE>
+    {%- endfor %}
+  </SW-VARIABLES>
+  {%- endif %}
+  {%- if diag_variable.comm_relations %}
+  <COMM-RELATIONS>
+    {%- for comm_relation in diag_variable.comm_relations %}
+    <COMM-RELATION>
+      {{ pd.printDescription(comm_relation.description) }}
+      <RELATION-TYPE>{{comm_relation.relation_type}}</RELATION-TYPE>
+      {%- if comm_relation.diag_comm_ref is not none %}
+      <DIAG-COMM-REF ID-REF="{{comm_relation.diag_comm_ref.ref_id}}" />
+      {%- endif %}
+      {%- if comm_relation.diag_comm_snref is not none %}
+      <DIAG-COMM-SNREF SHORT-NAME="{{comm_relation.diag_comm_snref}}" />
+      {%- endif %}
+      {%- if comm_relation.in_param_if_ref is not none %}
+      <IN-PARAM-IF-REF ID-REF="{{comm_relation.in_param_if_ref.ref_id}}" />
+      {%- endif %}
+      {%- if comm_relation.in_param_if_snref is not none %}
+      <IN-PARAM-IF-SNREF SHORT-NAME="{{comm_relation.in_param_if_snref}}" />
+      {%- endif %}
+      {%- if comm_relation.out_param_if_ref is not none %}
+      <OUT-PARAM-IF-REF ID-REF="{{comm_relation.out_param_if_ref.ref_id}}" />
+      {%- endif %}
+      {%- if comm_relation.out_param_if_snref is not none %}
+      <OUT-PARAM-IF-SNREF SHORT-NAME="{{comm_relation.out_param_if_snref}}" />
+      {%- endif %}
+      {%- if comm_relation.value_type_raw is not none %}
+      <VALUE-TYPE>{{comm_relation.value_type_raw.value}}</VALUE-TYPE>
+      {%- endif %}
+    <COMM-RELATION>
+    {%- endfor %}
+  </COMM-RELATIONS>
+  {%- endif %}
+</DIAG-VARIABLE>
+{%- endmacro -%}
+
+{%- macro printVariableGroup(var_group) -%}
+<VARIABLE-GROUP>
+  {{ peid.printElementIdSubtags(diag_variable)|indent(2) }}
+</VARIABLE-GROUP>
+{%- endmacro -%}

odxtools/templates/macros/printDynDefinedSpec.xml.jinja2

@@ -0,0 +1,48 @@
+{#- -*- mode: sgml; tab-width: 2; indent-tabs-mode: nil -*-
+ #
+ # SPDX-License-Identifier: MIT
+-#}
+
+{%- macro printDynDefinedSpec(dd_spec) -%}
+<DYN-DEFINED-SPEC>
+{%- if dd_spec.dyn_id_def_mode_infos %}
+<DYN-ID-DEF-MODE-INFOS>
+  {%- for diddmi in dd_spec.dyn_id_def_mode_infos %}
+  <DYN-ID-DEF-MODE-INFO>
+    <DEF-MODE>{{ diddmi.def_mode }}</DEF-MODE>
+    {%- if diddmi.clear_dyn_def_message_ref is not none %}
+    <CLEAR-DYN-DEF-MESSAGE-REF ID-REF="{{diddmi.clear_dyn_def_message_ref.ref_id}}" />
+    {%- endif %}
+    {%- if diddmi.clear_dyn_def_message_snref is not none %}
+    <CLEAR-DYN-DEF-MESSAGE-SNREF SHORT-NAME="{{diddmi.clear_dyn_def_message_snref}}" />
+    {%- endif %}
+    {%- if diddmi.read_dyn_def_message_ref is not none %}
+    <READ-DYN-DEF-MESSAGE-REF ID-REF="{{diddmi.read_dyn_def_message_ref.ref_id}}" />
+    {%- endif %}
+    {%- if diddmi.read_dyn_def_message_snref is not none %}
+    <READ-DYN-DEF-MESSAGE-SNREF SHORT-NAME="{{diddmi.read_dyn_def_message_snref}}" />
+    {%- endif %}
+    {%- if diddmi.supported_dyn_ids %}
+    <SUPPORTED-DYN-IDS>
+      {%- for dynid in diddmi.supported_dyn_ids %}
+      <SUPPORTED-DYN-ID>{{ dynid.hex() }}</SUPPORTED-DYN-ID>
+      {%- endfor %}
+    </SUPPORTED-DYN-IDS>
+    {%- endif %}
+    {%- if diddmi.selection_table_refs %}
+    <SELECTION-TABLE-REFS>
+      {%- for seltref in diddmi.selection_table_refs %}
+        {%- if hasattr(seltref, "ref_id") %}
+	<SELECTION-TABLE-REF ID-REF="{{ seltref.ref_id }}" />
+        {%- else %}
+	<SELECTION-TABLE-SNREF SHORT-NAME="{{ seltref }}" />
+        {%- endif %}
+      {%- endfor %}
+    </SELECTION-TABLE-REFS>
+    {%- endif %}
+  </DYN-ID-DEF-MODE-INFO>
+  {%- endfor %}
+</DYN-ID-DEF-MODE-INFOS>
+{%- endif %}
+</DYN-DEFINED-SPEC>
+{%- endmacro -%}

odxtools/templates/macros/printEcuVariantPattern.xml.jinja2

@@ -9,7 +9,7 @@
 
 {%- macro printMatchingParameter(mp) -%}
 <MATCHING-PARAMETER>
-  <EXPECTED-VALUE>{{mp.expected_value}}</EXPECTED-VALUE>
+  <EXPECTED-VALUE>{{mp.expected_value | e}}</EXPECTED-VALUE>
   <DIAG-COMM-SNREF SHORT-NAME="{{mp.diag_comm_snref}}" />
   {#- TODO: OUT-PARAM-IF-SNPATHREF #}
   <OUT-PARAM-IF-SNREF SHORT-NAME="{{mp.out_param_if}}" />

odxtools/templates/macros/printParam.xml.jinja2

@@ -35,8 +35,6 @@
 {%- endif %}
 {%- if param.coded_value is defined %}
  <CODED-VALUE>{{param.coded_value}}</CODED-VALUE>
-{%- elif param.physical_constant_value_raw is defined %}
- <PHYS-CONSTANT-VALUE>{{param.physical_constant_value_raw}}</PHYS-CONSTANT-VALUE>
 {%- elif param.coded_values is defined %}
  <CODED-VALUES>
  {%- for coded_value in param.coded_values %}
@@ -44,8 +42,11 @@
  {%- endfor %}
  </CODED-VALUES>
 {%- endif %}
-{%- if param.physical_default_value_raw %}
- <PHYSICAL-DEFAULT-VALUE>{{param.physical_default_value_raw}}</PHYSICAL-DEFAULT-VALUE>
+{%- if param.physical_constant_value_raw is defined %}
+ <PHYS-CONSTANT-VALUE>{{param.physical_constant_value_raw}}</PHYS-CONSTANT-VALUE>
+{%- endif %}
+{%- if param.physical_default_value_raw is defined and param.physical_default_value_raw is not none %}
+ <PHYSICAL-DEFAULT-VALUE>{{param.physical_default_value_raw | e}}</PHYSICAL-DEFAULT-VALUE>
 {%- endif %}
 {%- if param.dop_ref %}
  <DOP-REF ID-REF="{{param.dop_ref.ref_id}}"/>
@@ -53,10 +54,8 @@
  <DOP-SNREF SN="{{param.dop_snref}}"/>
 {%- elif param.diag_coded_type is defined %}
  {{pdop.printDiagCodedType(param.diag_coded_type)|indent(2)}}
-{%- elif param.parameter_type != "MATCHING-REQUEST-PARAM" %}
- {%- if param.bit_length is defined and param.bit_length is not none %}
-  <BIT-LENGTH>{{param.bit_length}}</BIT-LENGTH>
- {%- endif %}
+{%- elif param.bit_length is defined and param.bit_length is not none %}
+ <BIT-LENGTH>{{param.bit_length}}</BIT-LENGTH>
 {%- endif %}
 {%- if param.parameter_type == "TABLE-KEY" %}
  {%- if param.table_ref %}