odxtools 7.3.0__py3-none-any.whl → 7.4.1__py3-none-any.whl

odxtools/dyndefinedspec.py

@@ -0,0 +1,179 @@
+# SPDX-License-Identifier: MIT
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional, Union
+from xml.etree import ElementTree
+
+from .diagcomm import DiagClassType, DiagComm
+from .exceptions import odxraise, odxrequire
+from .nameditemlist import NamedItemList
+from .odxlink import OdxDocFragment, OdxLinkDatabase, OdxLinkId, OdxLinkRef, resolve_snref
+from .snrefcontext import SnRefContext
+from .table import Table
+
+
+@dataclass
+class DynIdDefModeInfo:
+    def_mode: str
+
+    clear_dyn_def_message_ref: Optional[OdxLinkRef]
+    clear_dyn_def_message_snref: Optional[str]
+
+    read_dyn_def_message_ref: Optional[OdxLinkRef]
+    read_dyn_def_message_snref: Optional[str]
+
+    dyn_def_message_ref: Optional[OdxLinkRef]
+    dyn_def_message_snref: Optional[str]
+
+    supported_dyn_ids: List[bytes]
+    selection_table_refs: List[Union[OdxLinkRef, str]]
+
+    @property
+    def clear_dyn_def_message(self) -> DiagComm:
+        return self._clear_dyn_def_message
+
+    @property
+    def read_dyn_def_message(self) -> DiagComm:
+        return self._read_dyn_def_message
+
+    @property
+    def dyn_def_message(self) -> DiagComm:
+        return self._dyn_def_message
+
+    @property
+    def selection_tables(self) -> NamedItemList[Table]:
+        return self._selection_tables
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DynIdDefModeInfo":
+        def_mode = odxrequire(et_element.findtext("DEF-MODE"))
+
+        clear_dyn_def_message_ref = OdxLinkRef.from_et(
+            et_element.find("CLEAR-DYN-DEF-MESSAGE-REF"), doc_frags)
+        if (snref_elem := et_element.find("CLEAR-DYN-DEF-MESSAGE-SNREF")) is not None:
+            clear_dyn_def_message_snref = snref_elem.attrib["SHORT-NAME"]
+
+        read_dyn_def_message_ref = OdxLinkRef.from_et(
+            et_element.find("READ-DYN-DEF-MESSAGE-REF"), doc_frags)
+        if (snref_elem := et_element.find("READ-DYN-DEF-MESSAGE-SNREF")) is not None:
+            read_dyn_def_message_snref = snref_elem.attrib["SHORT-NAME"]
+
+        dyn_def_message_ref = OdxLinkRef.from_et(et_element.find("DYN-DEF-MESSAGE-REF"), doc_frags)
+        if (snref_elem := et_element.find("DYN-DEF-MESSAGE-SNREF")) is not None:
+            dyn_def_message_snref = snref_elem.attrib["SHORT-NAME"]
+
+        supported_dyn_ids = [
+            bytes.fromhex(odxrequire(x.text))
+            for x in et_element.iterfind("SUPPORTED-DYN-IDS/SUPPORTED-DYN-ID")
+        ]
+
+        selection_table_refs: List[Union[OdxLinkRef, str]] = []
+        if (st_elems := et_element.find("SELECTION-TABLE-REFS")) is not None:
+            for st_elem in st_elems:
+                if st_elem.tag == "SELECTION-TABLE-REF":
+                    selection_table_refs.append(OdxLinkRef.from_et(st_elem, doc_frags))
+                elif st_elem.tag == "SELECTION-TABLE-SNREF":
+                    selection_table_refs.append(odxrequire(st_elem.get("SHORT-NAME")))
+                else:
+                    odxraise()
+
+        return DynIdDefModeInfo(
+            def_mode=def_mode,
+            clear_dyn_def_message_ref=clear_dyn_def_message_ref,
+            clear_dyn_def_message_snref=clear_dyn_def_message_snref,
+            read_dyn_def_message_ref=read_dyn_def_message_ref,
+            read_dyn_def_message_snref=read_dyn_def_message_snref,
+            dyn_def_message_ref=dyn_def_message_ref,
+            dyn_def_message_snref=dyn_def_message_snref,
+            supported_dyn_ids=supported_dyn_ids,
+            selection_table_refs=selection_table_refs,
+        )
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result: Dict[OdxLinkId, Any] = {}
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        self._selection_tables = NamedItemList[Table]()
+
+        if self.clear_dyn_def_message_ref is not None:
+            self._clear_dyn_def_message = odxlinks.resolve(self.clear_dyn_def_message_ref, DiagComm)
+
+        if self.read_dyn_def_message_ref is not None:
+            self._read_dyn_def_message = odxlinks.resolve(self.read_dyn_def_message_ref, DiagComm)
+
+        if self.dyn_def_message_ref is not None:
+            self._dyn_def_message = odxlinks.resolve(self.dyn_def_message_ref, DiagComm)
+
+        # resolve the selection tables referenced using ODXLINK
+        for x in self.selection_table_refs:
+            if isinstance(x, OdxLinkRef):
+                self._selection_tables.append(odxlinks.resolve(x, Table))
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        diag_layer = odxrequire(context.diag_layer)
+
+        if self.clear_dyn_def_message_snref is not None:
+            self._clear_dyn_def_message = resolve_snref(self.clear_dyn_def_message_snref,
+                                                        diag_layer.diag_comms, DiagComm)
+
+        if self.read_dyn_def_message_snref is not None:
+            self._read_dyn_def_message = resolve_snref(self.read_dyn_def_message_snref,
+                                                       diag_layer.diag_comms, DiagComm)
+
+        if self.dyn_def_message_snref is not None:
+            self._dyn_def_message = resolve_snref(self.dyn_def_message_snref, diag_layer.diag_comms,
+                                                  DiagComm)
+
+        if self._clear_dyn_def_message.diagnostic_class != DiagClassType.CLEAR_DYN_DEF_MESSAGE:
+            odxraise(
+                f"Diagnostic communication object of wrong type referenced: "
+                f"({odxrequire(self._clear_dyn_def_message.diagnostic_class).value} instead of "
+                f"CLEAR-DYN-DEF-MESSAGE)")
+        if self._read_dyn_def_message.diagnostic_class != DiagClassType.READ_DYN_DEFINED_MESSAGE:
+            odxraise(f"Diagnostic communication object of wrong type referenced: "
+                     f"({odxrequire(self._read_dyn_def_message.diagnostic_class).value} instead of "
+                     f"READ-DYN-DEFINED-MESSAGE)")
+        if self._dyn_def_message.diagnostic_class != DiagClassType.DYN_DEF_MESSAGE:
+            odxraise(f"Diagnostic communication object of wrong type referenced: "
+                     f"({odxrequire(self._dyn_def_message.diagnostic_class).value} instead of "
+                     f"DYN-DEF-MESSAGE)")
+
+        # resolve the remaining selection tables that are referenced via SNREF
+        for i, x in enumerate(self.selection_table_refs):
+            if isinstance(x, str):
+                ddd_spec = odxrequire(diag_layer.diag_data_dictionary_spec)
+                self._selection_tables.insert(i, resolve_snref(x, ddd_spec.tables, Table))
+
+
+@dataclass
+class DynDefinedSpec:
+    dyn_id_def_mode_infos: List[DynIdDefModeInfo]
+
+    @staticmethod
+    def from_et(et_element: ElementTree.Element,
+                doc_frags: List[OdxDocFragment]) -> "DynDefinedSpec":
+        dyn_id_def_mode_infos = [
+            DynIdDefModeInfo.from_et(x, doc_frags)
+            for x in et_element.iterfind("DYN-ID-DEF-MODE-INFOS/DYN-ID-DEF-MODE-INFO")
+        ]
+        return DynDefinedSpec(dyn_id_def_mode_infos=dyn_id_def_mode_infos)
+
+    def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
+        result: Dict[OdxLinkId, Any] = {}
+
+        result.update(self._build_odxlinks())
+
+        for didmi in self.dyn_id_def_mode_infos:
+            result.update(didmi._build_odxlinks())
+
+        return result
+
+    def _resolve_odxlinks(self, odxlinks: OdxLinkDatabase) -> None:
+        for didmi in self.dyn_id_def_mode_infos:
+            didmi._resolve_odxlinks(odxlinks)
+
+    def _resolve_snrefs(self, context: SnRefContext) -> None:
+        for didmi in self.dyn_id_def_mode_infos:
+            didmi._resolve_snrefs(context)

odxtools/environmentdatadescription.py

@@ -83,8 +83,9 @@ class EnvironmentDataDescription(ComplexDop):
     def _build_odxlinks(self) -> Dict[OdxLinkId, Any]:
         odxlinks = {self.odx_id: self}
 
-        for ed in self.env_datas:
-            odxlinks.update(ed._build_odxlinks())
+        if not self.env_data_refs:
+            for ed in self.env_datas:
+                odxlinks.update(ed._build_odxlinks())
 
         return odxlinks
 

odxtools/odxlink.py

@@ -4,29 +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:
-        return hash(self.doc_name) + hash(self.doc_type)
+    doc_type: str
 
 
 @dataclass(frozen=True)
@@ -121,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")
@@ -134,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
 
@@ -154,9 +140,9 @@ 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:
@@ -182,7 +168,7 @@ class OdxLinkDatabase:
             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}",

odxtools/parameterinfo.py

@@ -132,7 +132,16 @@ def parameter_info(param_list: Iterable[Parameter], quoted_names: bool = False)
                 val_str = ""
                 if scale.lower_limit is not None:
                     val_str = f"({repr(scale.lower_limit.value)})"
-                of.write(f"  {repr(scale.compu_const)}{val_str}\n")
+
+                if scale.compu_const is None:
+                    of.write(f"  <ERROR in ODX data: no value specified>\n")
+                else:
+                    vt = scale.compu_const.vt
+                    v = scale.compu_const.v
+                    if vt is not None:
+                        of.write(f"  \"{vt}\" {val_str}\n")
+                    else:
+                        of.write(f"  {v}\n")
 
         elif isinstance(cm, IdenticalCompuMethod):
             bdt = dop.physical_type.base_data_type

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 | e }}</{{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 %}

odxtools/templates/macros/printService.xml.jinja2

@@ -4,6 +4,7 @@
 -#}
 
 {%- import('macros/printDiagComm.xml.jinja2') as pdc %}
+{%- import('macros/printComparamRef.xml.jinja2') as pcom %}
 
 {%- macro printService(service) -%}
 <DIAG-SERVICE {{pdc.printDiagCommAttribs(service) | indent(1) }}
@@ -18,8 +19,8 @@
   {{pdc.printDiagCommSubtags(service) | indent(1, first=True) }}
   {%- if service.comparam_refs %}
   <COMPARAM-REFS>
-    {%- for ref in service.comparam_refs %}
-    <COMPARAM-REF ID-REF="{{ref.ref_id}}" />
+    {%- for cpref in service.comparam_refs %}
+    {{ pcom.printComparamRef(cpref)|indent(4) }}
     {%- endfor %}
   </COMPARAM-REFS>
   {%- endif%}

odxtools/templates/macros/printSingleEcuJob.xml.jinja2

@@ -65,8 +65,8 @@
 <INPUT-PARAM {{-make_xml_attrib("OID", param.oid)}}
              {{-make_xml_attrib("SEMANTIC", param.semantic)}}>
  {{ peid.printElementIdSubtags(param)|indent(1) }}
-{%- if param.physical_default_value %}
- <PHYSICAL-DEFAULT-VALUE>{{param.physical_default_value}}</PHYSICAL-DEFAULT-VALUE>
+{%- if param.physical_default_value is not none %}
+ <PHYSICAL-DEFAULT-VALUE>{{param.physical_default_value | e}}</PHYSICAL-DEFAULT-VALUE>
 {%- endif %}
  <DOP-BASE-REF ID-REF="{{param.dop_base_ref.ref_id}}" />
 </INPUT-PARAM>

odxtools/templates/macros/printVariant.xml.jinja2

@@ -26,6 +26,8 @@
 {%- import('macros/printAudience.xml.jinja2') as paud %}
 {%- import('macros/printSpecialData.xml.jinja2') as psd %}
 {%- import('macros/printEcuVariantPattern.xml.jinja2') as pvpat %}
+{%- import('macros/printDynDefinedSpec.xml.jinja2') as pdynspec %}
+{%- import('macros/printDiagVariable.xml.jinja2') as pdv %}
 
 {%- macro printVariant(dl) -%}
 {%- set dlr = dl.diag_layer_raw %}
@@ -124,9 +126,9 @@
  {%- endif %}
  </DIAG-DATA-DICTIONARY-SPEC>
 {%- endif %}
-{%- if dlr.diag_comms %}
+{%- if dlr.diag_comms_raw %}
  <DIAG-COMMS>
-   {%- for dc in dlr.diag_comms %}
+   {%- for dc in dlr.diag_comms_raw %}
 
    {#- use some serious duck typing to determine the kind of diag-comm
     #- object. this would not be necessary if something like
@@ -191,28 +193,43 @@
  </ADDITIONAL-AUDIENCES>
 {%- endif %}
 {{- psd.printSpecialDataGroups(dlr.sdgs)|indent(1, first=True) }}
-{%- if dlr.comparams %}
+{%- if dlr.comparam_refs %}
  <COMPARAM-REFS>
- {%- for cp in dlr.comparams -%}
+ {%- for cp in dlr.comparam_refs -%}
  {{ pcom.printComparamRef(cp)|indent(2) }}
  {%- endfor %}
  </COMPARAM-REFS>
 {%- endif %}
-{%- if dlr.variant_type.value == "ECU-VARIANT" %}
- {%- if dlr.ecu_variant_patterns %}
- <ECU-VARIANT-PATTERNS>
-   {%- for vp in dlr.ecu_variant_patterns -%}
-   {{ pvpat.printEcuVariantPattern(vp)|indent(2) }}
-   {%- endfor -%}
- </ECU-VARIANT-PATTERNS>
- {%- endif %}
-{%- endif %}
 {%- if dlr.variant_type.value == "PROTOCOL" %}
 	<COMPARAM-SPEC-REF ID-REF="{{dlr.comparam_spec_ref.ref_id}}" DOCREF="{{dlr.comparam_spec_ref.ref_docs[0].doc_name}}" DOCTYPE="COMPARAM-SPEC"/>
   {%- if dlr.prot_stack_snref is not none %}
   <PROT-STACK-SNREF SHORT-NAME="{{dlr.prot_stack_snref}}"/>
   {%- endif %}
 {%- endif %}
+{%- if dlr.diag_variables %}
+  <DIAG-VARIABLES>
+    {%- for dv in dlr.diag_variables -%}
+    {{ pdv.printDiagVariable(dv)|indent(4) }}
+    {%- endfor -%}
+  </DIAG-VARIABLES>
+{%- endif %}
+{%- if dlr.variable_groups %}
+  <VARIABLE-GROUPS>
+    {%- for vg in dlr.variable_groups -%}
+    {{ pdv.printVariableGroup(vg)|indent(4) }}
+    {%- endfor -%}
+  </VARIABLE-GROUPS>
+{%- endif %}
+{%- if dlr.dyn_defined_spec %}
+  {{ pdynspec.printPrintDefinedSpec(dlr.dyn_defined_spec)|indent(4) }}
+{%- endif %}
+{%- if dlr.ecu_variant_patterns %}
+  <ECU-VARIANT-PATTERNS>
+    {%- for vp in dlr.ecu_variant_patterns -%}
+    {{ pvpat.printEcuVariantPattern(vp)|indent(4) }}
+{%- endfor -%}
+  </ECU-VARIANT-PATTERNS>
+{%- endif %}
 {%- if dlr.parent_refs %}
  <PARENT-REFS>
  {%- for parent in dlr.parent_refs -%}