Memory Protection

import argparse
import xml.etree.ElementTree as ET

CRC_POLY_CCITT = 0x1021
VALUE = "storage"
SIZE = "dtype"

# Initialize global CRC lookup table
_crc_tabccitt = None
crc = 0

class CRCcompute:
    """Parses data from command line and calls the required renderers"""

    def __init__(self):
        """Constructor."""
        self.parser = argparse.ArgumentParser()
        self.parser.add_argument(
            "in_file", type=str, help="File path to a XCF containing the register list"
        )

    def parse_args(self, args=None):
        """Parses the input arguments."""
        self.args = self.parser.parse_args(args)

    def run(self):
        """Main execution method."""
        xml_tree = ET.parse(self.args.in_file).getroot()

        # Extract PartNumber from Device element
        device = xml_tree.find(".//Device")
        part_number = (
            device.attrib.get("PartNumber", "Unknown")
            if device is not None
            else "Unknown"
        )

        # Get the filename from the input file path
        import os

        config_file_name = os.path.basename(self.args.in_file)

        # Print the message
        print(
            f"Calculating configuration CRC for {part_number} using {config_file_name} configuration file"
        )
        print()  # Empty line

        # Navigate the nested structure to find Register elements
        registers = xml_tree.findall(".//Register")

        for idx, register in enumerate(registers):
            # Get the register ID
            reg_id = register.attrib.get("id", "")

            # Stop processing if we encounter a register with ID starting with "FSOE_"
            if reg_id.startswith("FSOE_"):
                print(f"Stopped at register: {reg_id} (excluding Safe registers)")
                print()  # Empty line
                break

            value = register.attrib[VALUE]
            size = register.attrib[SIZE]

            # Determine number of bytes from datatype
            size_map = {
                "u8": 1,
                "s16": 2,
                "u16": 2,
                "float": 4,
                "u32": 4,
                "s32": 4,
                "u64": 8,
                "s64": 8,
            }
            num_bytes = size_map.get(size, 2)  # Default to 2 bytes if unknown

            # Parse value based on datatype
            if size == "float":
                import struct

                # Convert float string to float, then to bytes
                float_value = float(value)
                reg_bytes = struct.pack(">f", float_value)  # big-endian float
            else:
                # For integer types, check if hex or decimal
                if value.startswith("0x"):
                    int_value = int(value, 16)
                else:
                    int_value = int(value)

                # Convert to bytes (big-endian)
                reg_bytes = int_value.to_bytes(
                    num_bytes, byteorder="big", signed=(size.startswith("s"))
                )

            # Reverse byte order for CRC calculation (little-endian)
            reg_bytes_reversed = bytes(reversed(reg_bytes))

            # Update CRC with the byte array
            out = self.__update_crc(reg_bytes_reversed, size)

        print(f"CRC: 0x{out:04X} (decimal: {out})")

    def __init_crcccitt_tab(self):
        """
        Initialize the CRC-CCITT lookup table.

        For optimal performance, the CRC-CCITT calculation uses a lookup table
        with pre-compiled values that can be directly applied in the XOR action.
        """
        global _crc_tabccitt

        _crc_tabccitt = []

        for i in range(256):
            crc = 0
            c = i << 8

            for j in range(8):
                if (crc ^ c) & 0x8000:
                    crc = (crc << 1) ^ CRC_POLY_CCITT
                else:
                    crc = crc << 1

                c = c << 1

            _crc_tabccitt.append(crc & 0xFFFF)

    def __update_crc(self, input_data, size_data):
        """
        Generic implementation of the CCITT CRC algorithm.

        Args:
            input_data: bytes or bytearray to calculate CRC for
            start_value: initial CRC value (uint16)

        Returns:
            uint16 CRC value
        """
        global _crc_tabccitt
        global crc

        if _crc_tabccitt is None:
            self.__init_crcccitt_tab()

        for byte in input_data:
            crc = ((crc << 8) ^ _crc_tabccitt[((crc >> 8) ^ byte) & 0x00FF]) & 0xFFFF

        return crc


if __name__ == "__main__":
    app = CRCcompute()
    app.parse_args()
    app.run()