import os import xml.etree.ElementTree as ET import struct import base64 from tools import load_constants, find_files_with_sha1, find_xml_files, convert_to_int_or_string, get_int_or_string_value, convert_to_int, convert_to_8bit ROM_DIR = 'ROM_test' XML_DIR_COMP = 'Computer_test' DIR_SAVE = 'MSX_test' def parse_msx_block(root): """ Parses a 'block' element from the XML and returns a dictionary with its properties. :param root: XML element :return: Dictionary with block details. """ result = {} start = convert_to_int_or_string(root.attrib.get("start", 0)) count = convert_to_int_or_string(root.attrib.get("count", None)) for element in root: result[element.tag] = (get_int_or_string_value(element), element.attrib) # Adjust the count to not exceed the limit if 'count' in result : if count is not None: print("Error, block contain multiple count") else : count = result['count'] else : if count is None: count = 4 if count > 4 - start: count = 4 - start result['block_start'] = start result['block_count'] = count return result def parse_msx_secondary(root): """ Parses a 'secondary' element from the XML and returns a dictionary with the parsed blocks. :param root: XML element :return: Dictionary containing 'block' key with list of blocks. """ blocks = [parse_msx_block(element) for element in root if element.tag == 'block'] return {'block': blocks} def parse_msx_primary(root): """ Parses a 'primary' element from the XML and returns a dictionary with its sub-elements. :param root: XML element :return: Dictionary containing parsed blocks and secondary slots. """ results = {} for element in root: if element.tag == 'secondary': slot = convert_to_int_or_string(element.attrib["slot"]) results.setdefault('secondary', {})[slot] = parse_msx_secondary(element) elif element.tag == 'block': results.setdefault('block', []).append(parse_msx_block(element)) else: print(f"Processing unknown element: {element.tag}") return results def parse_msx_config(root): """ Parses the entire XML root element. :param root: Root XML element . :return: Dictionary with parsed configuration. """ results = {} for element in root: if element.tag == 'primary': slot = convert_to_int_or_string(element.attrib["slot"]) results.setdefault('primary', {})[slot] = parse_msx_primary(element) else: value = get_int_or_string_value(element) if value: results[element.tag] = value return results def create_msx_config_header(type, outfile): """ Writes the MSX configuration header to the output file. :param type: Type MSX computer :param outfile: Opened file object for writing. """ typ = 0 if type == 'MSX2' : typ = 1 data = struct.pack('BBBBBBBB', ord('M'), ord('S'), ord('x'), typ, 0, 0, 0, 0) outfile.write(data) def add_block_type_to_file(address, typ, params, outfile, constants): """ Writes a one block configuration to the output file :param address: Block address {slot, subslo, block_start, block_count} :param typ: Type of block. :param params: List parameters. :param outfile: Opened file object for writing. :param constants: Dictionary with configuration constants. """ block_type = constants['block'][typ] data = struct.pack('BBBBBBBB', constants['conf']['BLOCK'], address, block_type, params[0], params[1], params[2], params[3], params[4]) print(f"BLOCK: {constants['conf']['BLOCK']} {address:02X} {block_type:02X} {params[0]:02X} {params[1]:02X} {params[2]:02X} {params[3]:02X} {params[4]:02X} {address >> 6}/{(address >> 4) & 3}/{(address >> 2) & 3} block_count: {((address&3)+1)} {typ}({block_type})") outfile.write(data) for i in range(len(params)): params[i] = 0 def create_msx_config_block(slot, subslot, blocks, outfile, files_with_sha1, constants): """ Writes a block configuration to the output file, including any ROM data if applicable. :param slot: Slot number. :param subslot: Subslot number. :param blocks: List of block configurations. :param outfile: Opened file object for writing. :param files_with_sha1: Dictionary of files with their SHA1 hashes. :param constants: Dictionary with configuration constants. """ for block in blocks: address = ((slot & 3) << 6) | ((subslot & 3) << 4) | ((block['block_start'] & 3) << 2) | ((block['block_count'] - 1) & 3) params = [0] * 5 if 'memory' in block: (typ, attributes) = block.pop('memory', (None, None)) if typ == 'ROM' : if 'SHA1' not in attributes: print(f"Missing SHA1 for ROM in slot {slot}/{subslot}") elif attributes['SHA1'] not in files_with_sha1: print(f"ROM SHA1 not found: {attributes['SHA1']} (ROM name: {attributes['filename']}) in slot {slot}/{subslot}") else : filename = files_with_sha1[attributes['SHA1']] file_size = os.path.getsize(filename) params[0] = (file_size + 16383) // 16384 add_block_type_to_file(address, typ, params, outfile, constants) if filename: with open(filename, 'rb') as source_file: data = source_file.read() outfile.write(data) current_size = len(data) padding_needed = ((current_size + 16383) // 16384) * 16384 - current_size if padding_needed > 0: outfile.write(b'\xff' * padding_needed) filename = None elif typ == 'RAM' : if "size" in attributes : value = convert_to_int(attributes["size"]) if value : params[0] = value // 16384 else : print(f"RAM size not integer : {attributes['size']} in slot {slot}/{subslot}") else : params[0] = block['block_count'] pattern = 1 if "pattern" in attributes : value = convert_to_int(attributes["pattern"]) if value : pattern = value params[1] = pattern add_block_type_to_file(address, typ, params, outfile, constants) else : print(f"memory type {typ} unknown in slot {slot}/{subslot}") if 'mapper' in block: (typ, attributes) = block.pop('mapper', (None, None)) if typ in constants['mapper'] : params[0] = constants['mapper'][typ] add_block_type_to_file(address, "MAPPER", params, outfile, constants) else : print(f"Error: unknown mapper '{typ}' in slot {slot}/{subslot}") if 'cart' in block: (typ, attributes) = block.pop('cart', (None, None)) value = None if typ == 'A' or typ == 'a' or typ == '0': value = 0 elif typ == 'B' or typ == 'b' or typ == '1' : value = 1 else : print(f"Error: unknown identify CART '{typ}' in slot {slot}/{subslot}") if value is not None: params[0] = value add_block_type_to_file(address, "SLOT", params, outfile, constants) if 'device' in block: (typ, attributes) = block.pop('device', (None, None)) if typ in constants['device']: params[0] = constants['device'][typ] if "param" in attributes: params[1] = convert_to_8bit(attributes['param']) add_block_type_to_file(address, "DEVICE", params, outfile, constants) device_mask = None device_port = None if "mask" in attributes: device_mask = convert_to_8bit(attributes['mask']) if "port" in attributes: device_port = convert_to_8bit(attributes['port']) if device_mask is None: device_mask = 0xFF #Default value params[0] = device_port params[1] = device_mask if "param" in attributes: params[2] = convert_to_8bit(attributes['param']) add_block_type_to_file(address, "IO_DEVICE", params, outfile, constants) else : print(f"Error: unknown device '{typ}' in slot {slot}/{subslot}") if 'ref' in block: (typ, attributes) = block.pop('ref', (None, None)) if typ == "DEVICE" : if "to_block" in attributes : value = convert_to_int(attributes["to_block"]) if value is not None: params[0] = value & 3 add_block_type_to_file(address, "REF_DEV", params, outfile, constants) else : print(f"Error: reference type '{typ}' value to_block is not integger in slot {slot}/{subslot}") else : print(f"Error: reference type '{typ}' missing value to_block in slot {slot}/{subslot}") elif typ == "MEMORY" : if "to_block" in attributes : value = convert_to_int(attributes["to_block"]) if value is not None: params[0] = value & 3 add_block_type_to_file(address, "REF_MEM", params, outfile, constants) else : print(f"Error: reference type '{typ}' value to_block is not integger in slot {slot}/{subslot}") else : print(f"Error: reference type '{typ}' missing value to_block in slot {slot}/{subslot}") else : print(f"Error: unknown reference type '{typ}' in slot {slot}/{subslot}") del block['block_start'] del block['block_count'] if block: print (f"Unknown block elements {block}") # elif block['type'] == 'REF_DEV': # print(f"slot {slot}/{subslot}") # print(block) # params[0] = block.get('block_ref', None) # else: # print(f"Error: unknown type '{block['type']}' in slot {slot}/{subslot}") # data = struct.pack('BBBBBBBB', constants['conf']['BLOCK'], address, block_type, params[0], params[1], params[2], params[3], params[4]) # print(f"BLOCK: {constants['conf']['BLOCK']} {address:02X} {block_type:02X} {params[0]:02X} {params[1]:02X} {params[2]:02X} {params[3]:02X} {params[4]:02X} {block['type']} block_count: {block['count']}") # outfile.write(data) # if filename: # with open(filename, 'rb') as source_file: # data = source_file.read() # outfile.write(data) # current_size = len(data) # padding_needed = ((current_size + 16383) // 16384) * 16384 - current_size # if padding_needed > 0: # outfile.write(b'\xff' * padding_needed) def create_msx_config_subslot(slot, secondary, outfile, files_with_sha1, constants): """ Writes the configuration for a subslot to the output file. :param slot: Slot number. :param secondary: Secondary slot configuration. :param outfile: Opened file object for writing. :param files_with_sha1: Dictionary of files with their SHA1 hashes. :param constants: Dictionary with configuration constants. """ for subslot, subslot_data in secondary.items(): if 'block' in subslot_data: create_msx_config_block(slot, subslot, subslot_data['block'], outfile, files_with_sha1, constants) def create_msx_config_primary(primary, outfile, files_with_sha1, constants): """ Writes the configuration for the primary slots to the output file. :param primary: Primary slot configuration. :param outfile: Opened file object for writing. :param files_with_sha1: Dictionary of files with their SHA1 hashes. :param constants: Dictionary with configuration constants. """ for slot, slot_data in primary.items(): if 'block' in slot_data: create_msx_config_block(slot, 0, slot_data['block'], outfile, files_with_sha1, constants) elif 'secondary' in slot_data: create_msx_config_subslot(slot, slot_data['secondary'], outfile, files_with_sha1, constants) def create_msx_config_kbd_layout(layout, outfile, constants): """ Writes the configuration for the kezboard layout to the output file. :param layout: Base64 encoded layout :param outfile: Opened file object for writing. :param constants: Dictionary with configuration constants. """ if layout: data = struct.pack('BBBBBBBB', constants['conf']['KEYBOARD_LAYOUT'], 0, 0, 0, 0, 0, 0, 0) outfile.write(data) outfile.write(base64.b64decode(layout)) def create_msx_config(config, file_name, path, files_with_sha1, constants): """ Creates the MSX configuration file based on the parsed configuration data. :param config: Parsed MSX configuration. :param file_name: Output file name. :param path: Output file path. :param files_with_sha1: Dictionary of files with their SHA1 hashes. :param constants: Dictionary with configuration constants. """ file_path = os.path.join(DIR_SAVE, path) os.makedirs(file_path, exist_ok=True) file_path = os.path.join(file_path, file_name + '.msx') with open(file_path, "wb") as outfile: create_msx_config_header(config.get('type', 'MSX1'), outfile) create_msx_config_primary(config.get('primary', {}), outfile, files_with_sha1, constants) create_msx_config_kbd_layout(config.get('kbd_layout', None), outfile, constants) def create_msx_conf(file_name, path, files_with_sha1, constants): """ Parses the XML configuration file and creates the corresponding MSX configuration file. :param file_name: Input XML file name (without extension). :param path: Relative path to the XML file. :param files_with_sha1: Dictionary of files with their SHA1 hashes. :param constants: Dictionary with configuration constants. """ file_path = os.path.join(XML_DIR_COMP, path, file_name + '.xml') try: tree = ET.parse(file_path) root = tree.getroot() if root.tag != "msxConfig": print(f"File {file_path} is not a valid msxConfig XML. Skipping.") return config = parse_msx_config(root) print(file_name) create_msx_config(config, file_name, path, files_with_sha1, constants) except (ET.ParseError, FileNotFoundError) as e: print(f"Error processing file {file_path}: {e}") files_with_sha1 = find_files_with_sha1(ROM_DIR) constants = load_constants() xml_files = find_xml_files(XML_DIR_COMP) for file_name, path in xml_files: create_msx_conf(file_name, path, files_with_sha1, constants)