py-eb-model 1.1.7__py3-none-any.whl → 1.1.9__py3-none-any.whl

eb_model/cli/pref_system_importer_cli.py

@@ -9,23 +9,31 @@ from ..writer import TextPreferenceModelWriter, ABProjectWriter
 from ..parser import PerfXdmParser
 from ..models import PreferenceModel
 
+
 def main():
     version = pkg_resources.require("py_eb_model")[0].version
 
     ap = argparse.ArgumentParser()
-    ap.add_argument("-v", "--verbose", required= False, help = "print debug information.", action = "store_true")
-    ap.add_argument("--file-list", required=False, help = "generate the file list (Default)", action = "store_true")
-    ap.add_argument("--ab-project", required=False, help = "generate the AUTOSAR builder project", action = "store_true")
-    ap.add_argument("--base-path", required=True, help="base Path for EB tresos")
-    ap.add_argument("--env", required=False, help="specify the environment variable", nargs='+')
-    ap.add_argument("--project", required=False, help="specify the project name")
-    ap.add_argument("INPUTS", nargs='+', help = "The path of perf_imp_xxx.xdm.")
-    ap.add_argument("OUTPUT", help = "The path of output file.")
+    ap.description = "PrefSystemImporter ver: %s" % version
+    ap.add_argument("-v", "--verbose", required=False,
+                    help="print debug information.", action="store_true")
+    ap.add_argument("--file-list", required=False,
+                    help="generate the file list (Default)", action="store_true")
+    ap.add_argument("--ab-project", required=False,
+                    help="generate the AUTOSAR builder project", action="store_true")
+    ap.add_argument("--base-path", required=True,
+                    help="base Path for EB tresos")
+    ap.add_argument("--env", required=False,
+                    help="specify the environment variable", nargs='+')
+    ap.add_argument("--project", required=False,
+                    help="specify the project name")
+    ap.add_argument("INPUTS", nargs='+', help="The path of perf_imp_xxx.xdm.")
+    ap.add_argument("OUTPUT", help="The path of output file.")
 
     args = ap.parse_args()
 
     logger = logging.getLogger()
-    
+
     formatter = logging.Formatter('[%(levelname)s] : %(message)s')
 
     stdout_handler = logging.StreamHandler(sys.stderr)
@@ -48,7 +56,7 @@ def main():
         stdout_handler.setLevel(logging.DEBUG)
     else:
         stdout_handler.setLevel(logging.INFO)
-    
+
     if args.verbose:
         logger.addHandler(file_handler)
     logger.addHandler(stdout_handler)
@@ -68,7 +76,8 @@ def main():
         parser = PerfXdmParser()
         for file in args.INPUTS:
             if args.base_path is not None:
-                file_name = os.path.realpath(os.path.join(args.base_path, file))
+                file_name = os.path.realpath(
+                    os.path.join(args.base_path, file))
             else:
                 file_name = file
             parser.parse_preference_xdm(file_name, doc)
@@ -80,7 +89,7 @@ def main():
                 m = re.match(r'(\w+)=([:\/\\\.\w]+)', env)
                 if m:
                     params["env_var:%s" % m.group(1)] = m.group(2)
-        #params['tresos_output_base_dir'] = args.TRESOS_OUTPUT_BASE_DIR
+        # params['tresos_output_base_dir'] = args.TRESOS_OUTPUT_BASE_DIR
 
         if format == "file_list":
             writer = TextPreferenceModelWriter()
@@ -88,7 +97,7 @@ def main():
         elif format == "ab_project":
             writer = ABProjectWriter()
             writer.writer_import_files(args.OUTPUT, doc.getSystemDescriptionImporter(), params)
-        
+
     except Exception as e:
         logger.error(e)
         raise e

eb_model/models/importer_xdm.py

@@ -36,12 +36,14 @@ class SystemDescriptionImporter(EcucObject):
             if m and m.group(1) in params:
                 old_input_file = input_file
                 input_file = params[m.group(1)] + m.group(2)
-                self.logger.info("Replace Environment Variable Path: %s => %s" % (old_input_file, os.path.realpath(input_file)))
+                # self.logger.info("Replace Environment Variable Path: %s => %s" % (old_input_file, os.path.realpath(input_file)))
+                self.logger.info("Replace Environment Variable Path: %s => %s" % (old_input_file, input_file))
             if params['base_path'] is not None:
                 if params['wildcard']:
                     m = re.match(r'(.+)\\(\*\.\w+)', input_file)
                     if m:
                         for file_name in self.parseWildcard(os.path.realpath(os.path.join(params['base_path'], input_file))):
+                            # self.logger.info("Add the file <%s>." % file_name)
                             file_list.append(file_name)
                     else:
                         file_list.append(os.path.realpath(os.path.join(params['base_path'], input_file)))

eb_model/models/nvm_xdm.py

@@ -2,18 +2,254 @@ from typing import List
 from ..models.abstract import EcucParamConfContainerDef, Module, EcucRefType
 
 
-class NvM(Module):
-    def __init__(self, parent):
-        super().__init__(parent, "NvM")
+class NvMTargetBlockReference(EcucParamConfContainerDef):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
 
-        self.NvMBlockDescriptors = []                       # type: List[NvMBlockDescriptor]
 
-    def getNvMBlockDescriptorList(self):
-        return self.NvMBlockDescriptors
+class NvMEaRef(NvMTargetBlockReference):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
+
+        self.NvMNameOfEaBlock: EcucRefType = None
 
-    def addNvMBlockDescriptor(self, value):
+    def getNvMNameOfEaBlock(self) -> EcucRefType:
+        return self.NvMNameOfEaBlock
+
+    def setNvMNameOfEaBlock(self, value: EcucRefType):
         if value is not None:
-            self.NvMBlockDescriptors.append(value)
+            self.NvMNameOfEaBlock = value
+        return self
+
+
+class NvMFeeRef(NvMTargetBlockReference):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
+
+        self.NvMNameOfFeeBlock: EcucRefType = None
+
+    def getNvMNameOfFeeBlock(self) -> EcucRefType:
+        return self.NvMNameOfFeeBlock
+
+    def setNvMNameOfFeeBlock(self, value: EcucRefType):
+        if value is not None:
+            self.NvMNameOfFeeBlock = value
+        return self
+
+
+class NvMCommon(EcucParamConfContainerDef):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
+
+        self.NvMApiConfigClass: str = None
+        self.NvMBswMMultiBlockJobStatusInformation: bool = None
+        self.NvMCompiledConfigId: int = None
+        self.NvMCrcNumOfBytes: int = None
+        self.NvMCsmRetryCounter: int = None
+        self.NvMDatasetSelectionBits: int = None
+        self.NvMDevErrorDetect: bool = None
+        self.NvMDynamicConfiguration: bool = None
+        self.NvMJobPrioritization: bool = None
+        self.NvMMainFunctionPeriod: float = None
+        self.NvMMultiBlockCallback: str = None
+        self.NvMPollingMode: bool = None
+        self.NvMRepeatMirrorOperations: int = None
+        self.NvMSetRamBlockStatusApi: bool = None
+        self.NvMSizeImmediateJobQueue: int = None
+        self.NvMSizeStandardJobQueue: int = None
+        self.NvMVersionInfoApi: bool = None
+        self.NvMBufferAlignmentValue: str = None
+        self.NvMEcucPartitionRefs: List[EcucRefType] = []
+        self.NvMMasterEcucPartitionRef: EcucRefType = None
+
+    def getNvMApiConfigClass(self) -> str:
+        return self.NvMApiConfigClass
+
+    def setNvMApiConfigClass(self, value: str):
+        if value is not None:
+            self.NvMApiConfigClass = value
+        return self
+
+    def getNvMBswMMultiBlockJobStatusInformation(self) -> bool:
+        return self.NvMBswMMultiBlockJobStatusInformation
+
+    def setNvMBswMMultiBlockJobStatusInformation(self, value: bool):
+        if value is not None:
+            self.NvMBswMMultiBlockJobStatusInformation = value
+        return self
+
+    def getNvMCompiledConfigId(self) -> int:
+        return self.NvMCompiledConfigId
+
+    def setNvMCompiledConfigId(self, value: int):
+        if value is not None:
+            self.NvMCompiledConfigId = value
+        return self
+
+    def getNvMCrcNumOfBytes(self) -> int:
+        return self.NvMCrcNumOfBytes
+
+    def setNvMCrcNumOfBytes(self, value: int):
+        if value is not None:
+            self.NvMCrcNumOfBytes = value
+        return self
+
+    def getNvMCsmRetryCounter(self) -> int:
+        return self.NvMCsmRetryCounter
+
+    def setNvMCsmRetryCounter(self, value: int):
+        if value is not None:
+            self.NvMCsmRetryCounter = value
+        return self
+
+    def getNvMDatasetSelectionBits(self) -> int:
+        return self.NvMDatasetSelectionBits
+
+    def setNvMDatasetSelectionBits(self, value: int):
+        if value is not None:
+            self.NvMDatasetSelectionBits = value
+        return self
+
+    def getNvMDevErrorDetect(self) -> bool:
+        return self.NvMDevErrorDetect
+
+    def setNvMDevErrorDetect(self, value: bool):
+        if value is not None:
+            self.NvMDevErrorDetect = value
+        return self
+
+    def getNvMDynamicConfiguration(self) -> bool:
+        return self.NvMDynamicConfiguration
+
+    def setNvMDynamicConfiguration(self, value: bool):
+        if value is not None:
+            self.NvMDynamicConfiguration = value
+        return self
+
+    def getNvMJobPrioritization(self) -> bool:
+        return self.NvMJobPrioritization
+
+    def setNvMJobPrioritization(self, value: bool):
+        if value is not None:
+            self.NvMJobPrioritization = value
+        return self
+
+    def getNvMMainFunctionPeriod(self) -> float:
+        return self.NvMMainFunctionPeriod
+
+    def setNvMMainFunctionPeriod(self, value: float):
+        if value is not None:
+            self.NvMMainFunctionPeriod = value
+        return self
+
+    def getNvMMultiBlockCallback(self) -> str:
+        return self.NvMMultiBlockCallback
+
+    def setNvMMultiBlockCallback(self, value: str):
+        if value is not None:
+            self.NvMMultiBlockCallback = value
+        return self
+
+    def getNvMPollingMode(self) -> bool:
+        return self.NvMPollingMode
+
+    def setNvMPollingMode(self, value: bool):
+        if value is not None:
+            self.NvMPollingMode = value
+        return self
+
+    def getNvMRepeatMirrorOperations(self) -> int:
+        return self.NvMRepeatMirrorOperations
+
+    def setNvMRepeatMirrorOperations(self, value: int):
+        if value is not None:
+            self.NvMRepeatMirrorOperations = value
+        return self
+
+    def getNvMSetRamBlockStatusApi(self) -> bool:
+        return self.NvMSetRamBlockStatusApi
+
+    def setNvMSetRamBlockStatusApi(self, value: bool):
+        if value is not None:
+            self.NvMSetRamBlockStatusApi = value
+        return self
+
+    def getNvMSizeImmediateJobQueue(self) -> int:
+        return self.NvMSizeImmediateJobQueue
+
+    def setNvMSizeImmediateJobQueue(self, value: int):
+        if value is not None:
+            self.NvMSizeImmediateJobQueue = value
+        return self
+
+    def getNvMSizeStandardJobQueue(self) -> int:
+        return self.NvMSizeStandardJobQueue
+
+    def setNvMSizeStandardJobQueue(self, value: int):
+        if value is not None:
+            self.NvMSizeStandardJobQueue = value
+        return self
+
+    def getNvMVersionInfoApi(self) -> bool:
+        return self.NvMVersionInfoApi
+
+    def setNvMVersionInfoApi(self, value: bool):
+        if value is not None:
+            self.NvMVersionInfoApi = value
+        return self
+
+    def getNvMBufferAlignmentValue(self) -> str:
+        return self.NvMBufferAlignmentValue
+
+    def setNvMBufferAlignmentValue(self, value: str):
+        if value is not None:
+            self.NvMBufferAlignmentValue = value
+        return self
+
+    def getNvMEcucPartitionRefList(self) -> List[EcucRefType]:
+        return self.NvMEcucPartitionRefs
+
+    def addNvMEcucPartitionRef(self, value: EcucRefType):
+        if value is not None:
+            self.NvMEcucPartitionRefs.append(value)
+        return self
+
+    def getNvMMasterEcucPartitionRef(self) -> EcucRefType:
+        return self.NvMMasterEcucPartitionRef
+
+    def setNvMMasterEcucPartitionRef(self, value: EcucRefType):
+        if value is not None:
+            self.NvMMasterEcucPartitionRef = value
+        return self
+
+
+class NvMSingleBlockCallback(EcucParamConfContainerDef):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
+
+        self.NvMSingleBlockCallbackFnc: str = None
+
+    def getNvMSingleBlockCallbackFnc(self) -> str:
+        return self.NvMSingleBlockCallbackFnc
+
+    def setNvMSingleBlockCallbackFnc(self, value: str):
+        if value is not None:
+            self.NvMSingleBlockCallbackFnc = value
+        return self
+
+
+class NvMInitBlockCallback(EcucParamConfContainerDef):
+    def __init__(self, parent, name):
+        super().__init__(parent, name)
+
+        self.NvMInitBlockCallbackFnc: str = None
+
+    def getNvMInitBlockCallbackFnc(self) -> str:
+        return self.NvMInitBlockCallbackFnc
+
+    def setNvMInitBlockCallbackFnc(self, value: str):
+        if value is not None:
+            self.NvMInitBlockCallbackFnc = value
         return self
 
 
@@ -23,11 +259,11 @@ class NvMBlockDescriptor(EcucParamConfContainerDef):
 
         self.nvMBlockCrcType = None                         # type: str # optional
         self.nvMBlockHeaderInclude = None                   # type: int # optional
-        self.nvMBlockJobPriority = None                     # type: str # required
+        self.nvMBlockJobPriority: int = None
         self.nvMBlockManagementType = None                  # type: str # required
         self.nvMBlockUseAutoValidation = None               # required
         self.nvMBlockUseCompression = None                  # required
-        self.nvMBlockUseCrc = None                          # required
+        self.nvMBlockUseCrc: bool = False
         self.nvMBlockUseCRCCompMechanism = None             # required
         self.NvMBlockUsePort = None                         # required
         self.nvMBlockUseSetRamBlockStatus = None            # required
@@ -44,7 +280,7 @@ class NvMBlockDescriptor(EcucParamConfContainerDef):
         self.nvMNvramDeviceId = None                        # required
         self.nvMRamBlockDataAddress = None                  # optional
         self.nvMReadRamBlockFromNvCallback = None           # optional
-        self.nvMResistantToChangedSw = None                 # required
+        self.nvMResistantToChangedSw: bool = False
         self.nvMRomBlockDataAddress = None                  # optional
         self.nvMRomBlockNum = None                          # required
         self.nvMSelectBlockForFirstInitAll = None           # optional
@@ -56,7 +292,15 @@ class NvMBlockDescriptor(EcucParamConfContainerDef):
         self.nvMWriteVerification = None                    # required
         self.nvMWriteVerificationDataSize = None            # required
         self.nvMBlockCipheringRef = None                    # optional
-        self.nvMBlockEcucPartitionRef = None                # type: EcucRefType # required
+        self.nvMBlockEcucPartitionRef: EcucRefType = None
+
+        self.nvMInitBlockCallback: NvMInitBlockCallback = None
+        self.nvMSingleBlockCallback: NvMSingleBlockCallback = None
+        self.nvMTargetBlockReference: NvMTargetBlockReference = None
+
+        # EB extended
+        self.nvMProvideRteJobFinishedPort: bool = False
+        self.nvMProvideRteServicePort: bool = False
 
     def getNvMBlockCrcType(self):
         return self.nvMBlockCrcType
@@ -345,3 +589,68 @@ class NvMBlockDescriptor(EcucParamConfContainerDef):
         if value is not None:
             self.nvMBlockEcucPartitionRef = value
         return self
+
+    def getNvMInitBlockCallback(self) -> NvMInitBlockCallback:
+        return self.nvMInitBlockCallback
+
+    def setNvMInitBlockCallback(self, value: NvMInitBlockCallback):
+        if value is not None:
+            self.nvMInitBlockCallback = value
+        return self
+
+    def getNvMSingleBlockCallback(self) -> NvMSingleBlockCallback:
+        return self.nvMSingleBlockCallback
+
+    def setNvMSingleBlockCallback(self, value: NvMSingleBlockCallback):
+        if value is not None:
+            self.nvMSingleBlockCallback = value
+        return self
+
+    def getNvMTargetBlockReference(self) -> NvMTargetBlockReference:
+        return self.nvMTargetBlockReference
+
+    def setNvMTargetBlockReference(self, value: NvMTargetBlockReference):
+        if value is not None:
+            self.nvMTargetBlockReference = value
+        return self
+
+    def getNvMProvideRteJobFinishedPort(self) -> bool:
+        return self.nvMProvideRteJobFinishedPort
+
+    def setNvMProvideRteJobFinishedPort(self, value: bool):
+        if value is not None:
+            self.nvMProvideRteJobFinishedPort = value
+        return self
+
+    def getNvMProvideRteServicePort(self) -> bool:
+        return self.nvMProvideRteServicePort
+
+    def setNvMProvideRteServicePort(self, value: bool):
+        if value is not None:
+            self.nvMProvideRteServicePort = value
+        return self
+
+
+class NvM(Module):
+    def __init__(self, parent):
+        super().__init__(parent, "NvM")
+
+        # type: List[NvMBlockDescriptor]
+        self.NvMBlockDescriptors = []
+        self.NvMCommon: NvMCommon = None
+
+    def getNvMCommon(self) -> NvMCommon:
+        return self.NvMCommon
+
+    def setNvMCommon(self, value: NvMCommon):
+        if value is not None:
+            self.NvMCommon = value
+        return self
+
+    def getNvMBlockDescriptorList(self) -> List[NvMBlockDescriptor]:
+        return self.NvMBlockDescriptors
+
+    def addNvMBlockDescriptor(self, value: NvMBlockDescriptor):
+        if value is not None:
+            self.NvMBlockDescriptors.append(value)
+        return self

eb_model/parser/eb_parser.py

@@ -63,6 +63,12 @@ class AbstractEbModelParser(metaclass=ABCMeta):
         if tag is None:
             raise KeyError("XPath d:var[@name='%s'] is invalid" % name)
         return self._convert_value(tag)
+    
+    def read_eb_origin_value(self, parent: ET.Element, name: str) -> str:
+        tag = parent.find(".//d:var[@name='%s']" % name, self.nsmap)
+        if tag is None:
+            return None
+        return self._convert_value(tag)
 
     def read_optional_value(self, parent: ET.Element, name: str, default_value=None) -> str:
         tag = parent.find(".//d:var[@name='%s']" % name, self.nsmap)

eb_model/parser/nvm_xdm_parser.py

@@ -1,6 +1,6 @@
 import xml.etree.ElementTree as ET
 
-from ..models.nvm_xdm import NvM, NvMBlockDescriptor
+from ..models.nvm_xdm import NvM, NvMBlockDescriptor, NvMCommon, NvMEaRef, NvMFeeRef, NvMInitBlockCallback, NvMSingleBlockCallback
 from ..models.eb_doc import EBModel
 from ..parser.eb_parser import AbstractEbModelParser
 
@@ -23,22 +23,99 @@ class NvMXdmParser(AbstractEbModelParser):
 
         self.nvm = nvm
 
+        self.read_nvm_common(element, nvm)
         self.read_nvm_block_descriptors(element, nvm)
 
+    def read_nvm_common(self, element: ET.Element, nvm: NvM):
+        ctr_tag = self.find_ctr_tag(element, "NvMCommon")
+        if ctr_tag is not None:
+            nvm_common = NvMCommon(nvm, "NvMCommon")
+            nvm_common.setNvMApiConfigClass(self.read_value(ctr_tag, "NvMApiConfigClass"))
+            nvm_common.setNvMBswMMultiBlockJobStatusInformation(self.read_value(ctr_tag, "NvMBswMMultiBlockJobStatusInformation"))
+            nvm_common.setNvMCompiledConfigId(self.read_value(ctr_tag, "NvMCompiledConfigId"))
+            nvm_common.setNvMCrcNumOfBytes(self.read_value(ctr_tag, "NvMCrcNumOfBytes"))
+            nvm_common.setNvMCsmRetryCounter(self.read_optional_value(ctr_tag, "NvMCsmRetryCounter"))
+            nvm_common.setNvMDatasetSelectionBits(self.read_value(ctr_tag, "NvMDatasetSelectionBits"))
+            nvm_common.setNvMDevErrorDetect(self.read_value(ctr_tag, "NvMDevErrorDetect"))
+            nvm_common.setNvMDynamicConfiguration(self.read_value(ctr_tag, "NvMDynamicConfiguration"))
+            nvm_common.setNvMJobPrioritization(self.read_value(ctr_tag, "NvMJobPrioritization"))
+            nvm_common.setNvMMainFunctionPeriod(self.read_value(ctr_tag, "NvMMainFunctionPeriod"))
+            nvm_common.setNvMMultiBlockCallback(self.read_optional_value(ctr_tag, "NvMMultiBlockCallback"))
+            nvm_common.setNvMPollingMode(self.read_value(ctr_tag, "NvMPollingMode"))
+            nvm_common.setNvMRepeatMirrorOperations(self.read_value(ctr_tag, "NvMRepeatMirrorOperations"))
+            nvm_common.setNvMSetRamBlockStatusApi(self.read_value(ctr_tag, "NvMSetRamBlockStatusApi"))
+            nvm_common.setNvMSizeImmediateJobQueue(self.read_optional_value(ctr_tag, "NvMSizeImmediateJobQueue"))
+            nvm_common.setNvMSizeStandardJobQueue(self.read_value(ctr_tag, "NvMSizeStandardJobQueue"))
+            nvm_common.setNvMVersionInfoApi(self.read_value(ctr_tag, "NvMVersionInfoApi"))
+            nvm_common.setNvMBufferAlignmentValue(self.read_value(ctr_tag, "NvMBufferAlignmentValue"))
+            for ref in self.read_ref_value_list(ctr_tag, "NvMEcucPartitionRef"):
+                nvm_common.addNvMEcucPartitionRef(ref)
+            nvm_common.setNvMMasterEcucPartitionRef(self.read_ref_value(ctr_tag, "NvMMasterEcucPartitionRef"))
+
+            nvm.setNvMCommon(nvm_common)
+
+    def read_nvm_init_block_callback(self, element: ET.Element, nvm_block: NvMBlockDescriptor):
+        ctr_tag = self.find_ctr_tag(element, "NvMInitBlockCallback")
+        if ctr_tag is not None:
+            init_block_callback = NvMInitBlockCallback(nvm_block, "NvMInitBlockCallback")
+            init_block_callback.setNvMInitBlockCallbackFnc(self.read_value(ctr_tag, "NvMInitBlockCallbackFnc"))
+            nvm_block.setNvMInitBlockCallback(init_block_callback)
+
+    def read_nvm_single_block_callback(self, element: ET.Element, nvm_block: NvMBlockDescriptor):
+        ctr_tag = self.find_ctr_tag(element, "NvMSingleBlockCallback")
+        if ctr_tag is not None:
+            single_block_callback = NvMSingleBlockCallback(nvm_block, "NvMSingleBlockCallback")
+            single_block_callback.setNvMSingleBlockCallbackFnc(self.read_value(ctr_tag, "NvMSingleBlockCallbackFnc"))
+            nvm_block.setNvMSingleBlockCallback(single_block_callback)
+
+    def read_nvm_block_target_block_reference(self, element: ET.Element, nvm_block: NvMBlockDescriptor):
+        block_ref = self.read_choice_value(element, "NvMTargetBlockReference")
+        if block_ref == "NvMEaRef":
+            ctr_tag = self.find_ctr_tag(element, "NvMEaRef")
+            if ctr_tag is not None:
+                ref = NvMEaRef(nvm_block, block_ref)
+                ref.setNvMNameOfEaBlock(self.read_ref_value(element, "NvMNameOfEaBlock"))
+                nvm_block.setNvMTargetBlockReference(ref)
+        elif block_ref == "NvMFeeRef":
+            ctr_tag = self.find_ctr_tag(element, "NvMFeeRef")
+            if ctr_tag is not None:
+                ref = NvMFeeRef(nvm_block, block_ref)
+                ref.setNvMNameOfFeeBlock(self.read_ref_value(element, "NvMNameOfFeeBlock"))
+                nvm_block.setNvMTargetBlockReference(ref)
+        else:
+            raise ValueError("Invalid block reference type <%s>" % block_ref)
+
     def read_nvm_block_descriptors(self, element: ET.Element, nvm: NvM):
         for ctr_tag in self.find_ctr_tag_list(element, "NvMBlockDescriptor"):
             nvm_block = NvMBlockDescriptor(nvm, ctr_tag.attrib["name"])
-            nvm_block.setNvMBlockCrcType(self.read_optional_value(ctr_tag, "NvMBlockCrcType")) \
-                     .setNvMBlockEcucPartitionRef(self.read_ref_value(ctr_tag, "NvMBlockEcucPartitionRef")) \
-                     .setNvMNvramBlockIdentifier(self.read_value(ctr_tag, "NvMNvramBlockIdentifier")) \
-                     .setNvMRamBlockDataAddress(self.read_optional_value(ctr_tag, "NvMRamBlockDataAddress")) \
-                     .setNvMRomBlockDataAddress(self.read_optional_value(ctr_tag, "NvMRomBlockDataAddress")) \
-                     .setNvMRomBlockNum(self.read_value(ctr_tag, "NvMRomBlockNum")) \
-                     .setNvMBlockManagementType(self.read_value(ctr_tag, "NvMBlockManagementType")) \
-                     .setNvMNvBlockLength(self.read_value(ctr_tag, "NvMNvBlockLength")) \
-                     .setNvMNvBlockNum(self.read_value(ctr_tag, "NvMNvBlockNum")) \
-                     .setNvMSelectBlockForReadAll(self.read_value(ctr_tag, "NvMSelectBlockForReadAll")) \
-                     .setNvMSelectBlockForWriteAll(self.read_value(ctr_tag, "NvMSelectBlockForWriteAll")) 
+            nvm_block.setNvMBlockCrcType(self.read_optional_value(ctr_tag, "NvMBlockCrcType"))
+            nvm_block.setNvMBlockEcucPartitionRef(self.read_ref_value(ctr_tag, "NvMBlockEcucPartitionRef"))
+            nvm_block.setNvMNvramBlockIdentifier(self.read_value(ctr_tag, "NvMNvramBlockIdentifier"))
+            nvm_block.setNvMRamBlockDataAddress(self.read_optional_value(ctr_tag, "NvMRamBlockDataAddress"))
+            nvm_block.setNvMRomBlockDataAddress(self.read_optional_value(ctr_tag, "NvMRomBlockDataAddress"))
+            nvm_block.setNvMBlockJobPriority(self.read_value(ctr_tag, "NvMBlockJobPriority"))
+            nvm_block.setNvMResistantToChangedSw(self.read_value(ctr_tag, "NvMResistantToChangedSw"))
+            nvm_block.setNvMBlockCrcType(self.read_value(ctr_tag, "NvMBlockCrcType"))
+            nvm_block.setNvMBlockUseCrc(self.read_value(ctr_tag, "NvMBlockUseCrc"))
+            nvm_block.setNvMRomBlockNum(self.read_value(ctr_tag, "NvMRomBlockNum"))
+            nvm_block.setNvMBlockManagementType(self.read_value(ctr_tag, "NvMBlockManagementType"))
+            nvm_block.setNvMNvBlockLength(self.read_value(ctr_tag, "NvMNvBlockLength"))
+            nvm_block.setNvMNvBlockNum(self.read_value(ctr_tag, "NvMNvBlockNum"))
+            nvm_block.setNvMSelectBlockForReadAll(self.read_value(ctr_tag, "NvMSelectBlockForReadAll"))
+            nvm_block.setNvMSelectBlockForWriteAll(self.read_value(ctr_tag, "NvMSelectBlockForWriteAll"))
+
+            nvm_block.setNvMProvideRteJobFinishedPort(self.read_value(ctr_tag, "NvMProvideRteJobFinishedPort"))
+            nvm_block.setNvMProvideRteServicePort(self.read_value(ctr_tag, "NvMProvideRteServicePort"))
+
+            nvm_block.setNvMReadRamBlockFromNvCallback(self.read_optional_value(ctr_tag, "NvMReadRamBlockFromNvCallback"))
+            nvm_block.setNvMWriteRamBlockToNvCallback(self.read_optional_value(ctr_tag, "NvMWriteRamBlockToNvCallback"))
+            nvm_block.setNvMBlockUseSyncMechanism(self.read_value(ctr_tag, "NvMBlockUseSyncMechanism"))
+
+            self.read_nvm_init_block_callback(ctr_tag, nvm_block)
+            self.read_nvm_single_block_callback(ctr_tag, nvm_block)
+            
+            nvm_block.setNvMNvBlockBaseNumber(self.read_value(ctr_tag, "NvMNvBlockBaseNumber"))
+            self.read_nvm_block_target_block_reference(ctr_tag, nvm_block)
 
             nvm.addNvMBlockDescriptor(nvm_block)