python 实现HEX文件中有效数据提取段间隙填充FF

根据HEX文件规则提取文件中的有效数据（要写入芯片的数据），中间要注意扩展地址，以及各个段直接的间隙。话不多说，直接上代码

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

import os

class HexParser():
    
    file_path = ''
    fill_byte = 0xFF
    all_hex_string = ''

        
    def hexFileParser(self):
        print("001")
        try:
            if not os.path.exists(self.file_path):
                print("文件不存在")
                return
                
            memory_map = {}
            extended_linear_address = 0
            extended_segment_address = 0
            min_address = 0xFFFFFFFF
            max_address = 0
            total_lines = 0
            # 统计总行数
            with open(self.file_path, 'r', encoding='utf-8') as f:
                for _ in f:
                    total_lines += 1
            current_line = 0
            with open(self.file_path, 'r', encoding='utf-8') as f:
                for line in f:
                    current_line += 1
                    
                    line = line.strip()
                    if not line.startswith(':'):
                        continue
                        
                    data_line = line[1:]
                    if len(data_line) < 10:
                        continue
                        
                    try:
                        record_length = int(data_line[0:2], 16)
                        address = int(data_line[2:6], 16)
                        record_type = int(data_line[6:8], 16)
                        data_hex = data_line[8:8+record_length*2]
                        
                        if record_type == 0x00:  # 数据记录
                            full_address = extended_linear_address + extended_segment_address + address
                            
                            min_address = min(min_address, full_address)
                            max_address = max(max_address, full_address + record_length - 1)
                            
                            for i in range(0, len(data_hex), 2):
                                byte_value = int(data_hex[i:i+2], 16)
                                memory_map[full_address + i//2] = byte_value
                            
                        elif record_type == 0x02:  # 扩展段地址记录
                            extended_segment_address = int(data_hex, 16) * 16
                            extended_linear_address = 0
                            print("扩展段地址记录")
                            
                        elif record_type == 0x04:  # 扩展线性地址记录
                            extended_linear_address = int(data_hex, 16) << 16
                            extended_segment_address = 0
                            print("扩展段地址记录1")
                            
                        elif record_type == 0x01:  # 文件结束记录
                            break
                            
                    except ValueError:
                        continue
            
            if min_address > max_address:
                print("未找到有效数据")
                return
                
            # 填充地址间隙
            total_length = max_address - min_address + 1
            binary_data = bytearray(total_length)
            
            for i in range(total_length):
                binary_data[i] = self.fill_byte
                
            for address, value in memory_map.items():
                offset = address - min_address
                if 0 <= offset < total_length:
                    binary_data[offset] = value
            
            hex_string = binary_data.hex().upper()
            self.all_hex_string = hex_string
            
        except Exception as e:
            #self.error_occurred.emit(f"解析错误: {str(e)}")
            self.all_hex_string = ''
            return