keil-build-viewer.c

/**
 * \file            keil-build-viewer.c
 * \brief           main application
 */

/*
 * Copyright (c) 2023 Dino Haw
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
 * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 *
 * This file is keil-build-viewer.
 *
 * Author:        Dino Haw <347341799@qq.com>
 * Version:       v1.6
 * Change Logs:
 * Version  Date         Author     Notes
 * v1.0     2023-11-10   Dino       the first version
 * v1.1     2023-11-11   Dino       1. 适配 RAM 和 ROM 的解析
 * v1.2     2023-11-11   Dino       1. 适配 keil4 的 map 文件
 *                                  2. 增加检测到开启 LTO 后打印提示信息
 *                                  3. 修复开启 LTO 后无打印 region 的问题
 * v1.3     2023-11-12   Dino       1. 修复工程存在多个 lib 时仅解析一个的问题
 * v1.4     2023-11-21   Dino       1. 增加将本工具放置于系统环境变量 Path 所含目录的功能
 * v1.5     2023-11-30   Dino       1. 新增更多的 progress bar 样式
 *                                  2. 新增解析自定义的 memory area
 *                                  3. 修复 RAM 和 ROM 信息缺失时显示异常的问题
 * v1.5a    2023-11-30   Dino       1. 修复 object 数据溢出的问题
 *                                  2. 修改进度条内存大小的显示策略，不再四舍五入
 * v1.5b    2023-12-02   Dino       1. 【修复】保存文件路径内存动态分配过小的问题
 * v1.6     2024-12-11   Dino       1. 【修复】有多个 region 时导致显示回车多行的问题
 *                                  2. 【修复】Execution Region 被错误识别的问题
 *                                  3. 【修复】当 Execution Region 在其他 Loard Region 中使用会重复显示的问题
 *                                  4. 【修改】将未使用的 memory 放在同一分类显示
 *                                  5. 【修改】若 Execution Region Size 为 UINT32_MAX 时，则修改为对应 memory 的 Size
 */

/* Includes ------------------------------------------------------------------*/
#include "keil-build-viewer.h"


/* Private variables ---------------------------------------------------------*/
static FILE *                   _log_file;
static bool                     _is_save_log = true;
static bool                     _is_has_unused_region;
static bool                     _is_display_object = true;
static bool                     _is_display_path   = true;
static char                     _line_text[1024];
static char *                   _current_dir;
static ENCODING_TYPE            _encoding_type  = ENCODING_TYPE_GBK;
static PROGRESS_STYLE           _progress_style = PROGRESS_STYLE_0;
static struct prj_path_list *   _keil_prj_path_list;
static struct memory_info *     _memory_info_head;
static struct file_path_list *  _file_path_list_head;
static const char *             _keil_prj_extension[] = 
{
    ".uvprojx",
    ".uvproj"
};
static struct command_list      _command_list[] = 
{
    {
        .cmd  = "-NOLOG",
        .desc = "NOT save log file",
    },
    {
        .cmd  = "-OBJ",
        .desc = "Display the ram and flash occupancy of each object file (default)",
    },
    {
        .cmd  = "-NOOBJ",
        .desc = "NOT display the ram and flash occupancy of each object file",
    },
    {
        .cmd  = "-PATH",
        .desc = "Display each object file path (default)",
    },
    {
        .cmd  = "-NOPATH",
        .desc = "NOT display each object file path",
    },
    {
        .cmd  = "-STYLE0",
        .desc = "Progress bar style: following system (default)",
    },
    {
        .cmd  = "-STYLE1",
        .desc = "Progress bar style: |###OOO____| (when non-Chinese and not specified progress bar style)",
    },
    {
        .cmd  = "-STYLE2",
        .desc = "Progress bar style: |XXXOOO____|",
    },
};


/**
 * @brief  主程序
 * @note   
 * @param  argc:    参数数量
 * @param  argv[]:  参数列表
 * @retval 0: 正常 | -x: 错误
 */
int main(int argc, char *argv[])
{
    clock_t run_time = clock();

    struct load_region *load_region_head = NULL;
    struct object_info *object_info_head = NULL;
    struct load_region *record_load_region_head = NULL;
    struct object_info *record_object_info_head = NULL;

    /* 获取编码格式 */
    UINT acp = GetACP();
    if (acp == 936) {
        _encoding_type = ENCODING_TYPE_GBK;
    } 
    else if (acp == 950) {
        _encoding_type = ENCODING_TYPE_BIG5;
    } 
    else {
        _encoding_type = ENCODING_TYPE_OTHER;
    }

    /* 1. 获取程序运行的工作目录 */
    int result = 0;
    DWORD buff_len = GetCurrentDirectory(0, NULL);
    if (buff_len == 0) 
    {
        printf("\n[ERROR] %s %s\n", APP_NAME, APP_VERSION);
        printf("[ERROR] Get current directory length failed (code: %d)\n", GetLastError());
        result = -20;
        goto __exit;
    }

    _current_dir = (char *)malloc(buff_len + 1);
    if (_current_dir == NULL) 
    {
        printf("\n[ERROR] %s %s\n", APP_NAME, APP_VERSION);
        printf("[ERROR] Failed to allocate current directory memory\n");
        result = -21;
        goto __exit;
    }

    buff_len = GetCurrentDirectory(buff_len, _current_dir);
    if (buff_len == 0) 
    {
        printf("\n[ERROR] %s %s\n", APP_NAME, APP_VERSION);
        printf("[ERROR] Get current directory failed. (code: %d)\n", GetLastError());
        result = -22;
        goto __exit;
    }

    /* 创建 log 文件 */
    char *file_path = NULL;
    size_t file_path_size = 0;

    if (buff_len < MAX_PATH) {
        file_path_size = MAX_PATH * 2;
    } else {
        file_path_size = buff_len * 2;
    }
    file_path = (char *)malloc(file_path_size);
    if (file_path == NULL) 
    {
        printf("\n[ERROR] %s %s\n", APP_NAME, APP_VERSION);
        printf("[ERROR] Failed to allocate file path memory\n");
        result = -23;
        goto __exit;
    }

    /* 2. 搜索同级目录或指定目录下的所有 keil 工程并打印 */
    _keil_prj_path_list = prj_path_list_init(MAX_PATH_QTY);

    search_files_by_extension(_current_dir,
                              buff_len,
                              _keil_prj_extension, 
                              sizeof(_keil_prj_extension) / sizeof(char *),
                              _keil_prj_path_list);

    snprintf(file_path, file_path_size, "%s\\%s.log", _current_dir, APP_NAME);

    /* 3. 参数处理 */
    char input_param[MAX_PATH] = {0};
    char keil_prj_name[MAX_PRJ_NAME_SIZE] = {0};
    if (argc > 1)
    {
        int err_param = 0;
        int res = parameter_process(argc, 
                                    argv, 
                                    keil_prj_name, 
                                    sizeof(keil_prj_name), 
                                    input_param, 
                                    sizeof(input_param),
                                    &err_param);

        if (_is_save_log) {
            _log_file = fopen(file_path, "w+");
        }

        if (res == -1)
        {
            log_print(_log_file, "\n[ERROR] INVALID INPUT (code: %d): %s\n", GetLastError(), argv[1]);
            result = -1;
            goto __exit;
        }
        else if (res == -2)
        {
            log_print(_log_file, "\n[ERROR] INVALID INPUT: %s\n", argv[1]);
            log_print(_log_file, "[ERROR] Please enter the absolute path or keil project name with extension\n");
            result = -2;
            goto __exit;
        }
        else if (res == -3)
        {
            log_print(_log_file, "\n[ERROR] INVALID INPUT: %s\n", argv[err_param]);
            log_print(_log_file, "[ERROR] Only the following commands are supported\n");
            for (size_t i = 0; i < sizeof(_command_list) / sizeof(struct command_list); i++) {
                log_print(_log_file, "\t%s\t %s\n", _command_list[i].cmd, _command_list[i].desc);
            }
            result = -3;
            goto __exit;
        }
        else if (res == -4)
        {
            log_print(_log_file, "\nYou can control the displayed information by entering the following commands\n \n");
            for (size_t i = 0; i < sizeof(_command_list) / sizeof(struct command_list); i++) {
                log_print(_log_file, "\t%s\t %s\n", _command_list[i].cmd, _command_list[i].desc);
            }
            result = 0;
            goto __exit;
        }
    }
    else {
        _log_file = fopen(file_path, "w+");
    }

    log_print(_log_file, "\n=================================================== %s %s ==================================================\n ", APP_NAME, APP_VERSION);

    if (_keil_prj_path_list->size > 0) {
        log_save(_log_file, "\n[Search keil project] %d item(s)\n", _keil_prj_path_list->size);
    }

    for (size_t i = 0; i < _keil_prj_path_list->size; i++) {
        log_save(_log_file, "\t%s\n", _keil_prj_path_list->items[i]);
    }

    log_save(_log_file, "\n[User input] %s\n", input_param);
    log_save(_log_file, "[Current folder] %s\n", _current_dir);
    log_save(_log_file, "[Encoding] %d\n", acp);

    /* 4. 确定 keil 工程 */
    char *keil_prj_path;
    if (input_param[0] != '\0')
    {
        log_print(_log_file, "\n[Hint] You specify the keil project!\n");
        keil_prj_path = input_param;
    }
    else if (_keil_prj_path_list->size > 0)
    {
        keil_prj_path = _keil_prj_path_list->items[_keil_prj_path_list->size - 1];

        char *last_slash = strrchr(keil_prj_path, '\\');
        if (last_slash) 
        {
            last_slash += 1;
            strncpy_s(keil_prj_name, sizeof(keil_prj_name), last_slash, strnlen(last_slash, sizeof(keil_prj_name)));
        }
    }
    else
    {
        log_print(_log_file, "\n[ERROR] NO keil project found\n");
        log_print(_log_file, "[ERROR] Please check: %s\n", input_param);
        result = -4;
        goto __exit;
    }

    log_save(_log_file, "[Keil project path] %s\n", keil_prj_path);
    log_save(_log_file, "[Keil project name] %s\n", keil_prj_name);

    bool is_keil4_prj = false;
    if (keil_prj_name[strlen(keil_prj_name) - 1] == 'j') {
        is_keil4_prj = true;
    }
    log_save(_log_file, "[Is keil v4] %d\n", is_keil4_prj);

    char keil_prj_full_name[MAX_PRJ_NAME_SIZE] = {0};
    memcpy_s(keil_prj_full_name, sizeof(keil_prj_full_name), keil_prj_name, strnlen_s(keil_prj_name, sizeof(keil_prj_full_name)));
    char *dot = strrchr(keil_prj_name, '.');
    if (dot) {
        *dot = '\0';
    }

    /* 5. 获取启用的 project target */
    /* 打开同名的 .uvoptx 或 .uvopt 文件 */
    char target_name[MAX_PRJ_NAME_SIZE] = {0};
    snprintf(file_path, file_path_size, "%s\\%s.uvopt", _current_dir, keil_prj_name);
    if (is_keil4_prj == false) {
        strncat_s(file_path, file_path_size, "x", 1);
    }

    /* 不存在 uvoptx 文件时，默认选择第一个 target name */
    bool is_has_target = true;
    if (uvoptx_file_process(file_path, target_name, sizeof(target_name)) == false) 
    {
        is_has_target = false;
        log_print(_log_file, "\n[WARNING] can't open '%s'\n", file_path);
        log_print(_log_file, "[WARNING] The first project target is selected by default.\n");
    }

    /* 6. 获取 map 和 htm 文件所在的目录及 device 和 output_name 信息 */
    /* 打开同名的 .uvprojx 或 .uvproj 文件 */
    snprintf(file_path, file_path_size, "%s\\%s.uvproj", _current_dir, keil_prj_name);
    if (is_keil4_prj == false) {
        strncat_s(file_path, file_path_size, "x", 1);
    }
    
    char target_name_label[MAX_PRJ_NAME_SIZE * 2] = {0};

    if (is_has_target) {
        snprintf(target_name_label, sizeof(target_name_label), "%s%s", LABEL_TARGET_NAME, target_name);    
    } else {
        strncpy_s(target_name_label, sizeof(target_name_label), LABEL_TARGET_NAME, strlen(LABEL_TARGET_NAME));
    }

    struct uvprojx_info uvprojx_file = {0};
    int res = uvprojx_file_process(file_path, 
                                   target_name_label, 
                                   &uvprojx_file, 
                                   !is_has_target);
    if (res == -1)
    {
        log_print(_log_file, "\n[ERROR] can't open .uvproj(x) file\n");
        log_print(_log_file, "[ERROR] Please check: %s\n", file_path);
        result = -5;
        goto __exit;
    }
    else if (res == -2)
    {
        log_print(_log_file, "\n[ERROR] <Cpu> contains unsupported types\n");
        log_print(_log_file, "[ERROR] Please check: %s\n", file_path);
        result = -6;
        goto __exit;
    }
    else if (res == -3)
    {
        log_print(_log_file, "\n[ERROR] generate map file is not checked (Options for Target -> Listing -> Linker Listing)\n");
        result = -7;
        goto __exit;
    }

    log_save(_log_file, "\n[Device] %s\n", uvprojx_file.chip);
    log_save(_log_file, "[Target name] %s\n", uvprojx_file.target_name);
    log_save(_log_file, "[Output name] %s\n", uvprojx_file.output_name);
    log_save(_log_file, "[Output path] %s\n", uvprojx_file.output_path);
    log_save(_log_file, "[Listing path] %s\n", uvprojx_file.listing_path);
    log_save(_log_file, "[Is has pack] %d\n", uvprojx_file.is_has_pack);
    log_save(_log_file, "[Is enbale LTO] %d\n", uvprojx_file.is_enable_lto);
    log_save(_log_file, "[Is has user library] %d\n", uvprojx_file.is_has_user_lib);
    log_save(_log_file, "[Is custom scatter file] %d\n", uvprojx_file.is_custom_scatter);

    if (uvprojx_file.output_name[0] == '\0') 
    {
        log_print(_log_file, "\n[ERROR] output name is empty\n");
        log_print(_log_file, "[ERROR] Please check: %s\n", file_path);
        result = -8;
        goto __exit;
    }
    if (uvprojx_file.listing_path[0] == '\0') 
    {
        log_print(_log_file, "\n[ERROR] listing path is empty\n");
        log_print(_log_file, "[ERROR] Please check: %s\n", file_path);
        result = -9;
        goto __exit;
    }

    char *p_target_name = target_name;
    if (is_has_target == false) {
        p_target_name = uvprojx_file.target_name;
    }
    log_print(_log_file, "\n[%s]  [%s]  [%s]", keil_prj_full_name, p_target_name, uvprojx_file.chip);

    if (uvprojx_file.is_enable_lto) {
        log_print(_log_file, "  [LTO enable]\n \n");
    } else {
        log_print(_log_file, "  [LTO disable]\n \n");
    }

    log_save(_log_file, "[memory info]\n");
    for (struct memory_info *memory = _memory_info_head; 
         memory != NULL; 
         memory = memory->next)
    {
        log_save(_log_file, "[name] %s [base addr] 0x%08X [size] 0x%08X [type] %d [off-chip] %d [is pack] %d [ID] %d \n", 
                 memory->name, memory->base_addr, memory->size, memory->type, memory->is_offchip, memory->is_from_pack, memory->id);
    }

    /* 7. 从 build_log 文件中获取被改名的文件信息 */
    if (uvprojx_file.output_path[0] != '\0')
    {
        res = combine_path(file_path, file_path_size, keil_prj_path, uvprojx_file.output_path);
        snprintf(file_path, file_path_size, "%s%s.build_log.htm", file_path, uvprojx_file.output_name);
        if (res == 0)
        {
            build_log_file_process(file_path);
        }
        if (res == -1)
        {
            log_print(_log_file, "\n[WARNING] %s not a absolute path\n", keil_prj_path);
            log_print(_log_file, "[WARNING] path: %s\n \n", file_path);
        }
        else if (res == -2)
        {
            log_print(_log_file, "\n[WARNING] relative paths go up more levels than absolute paths\n");
            log_print(_log_file, "[WARNING] path: %s\n \n", file_path);
        }
    }
    else {
        log_print(_log_file, "\n[WARNING] %s is empty, can't read '.build_log.htm' file\n \n", LABEL_OUTPUT_DIRECTORY);
    }

    /* 8. 处理剩余的重名文件 */
    file_rename_process();

    /* 9. 打开 map 文件，获取 Load Region 和 Execution Region */
    res = combine_path(file_path, file_path_size, keil_prj_path, uvprojx_file.listing_path);
    if (res == -1)
    {
        log_print(_log_file, "\n[ERROR] %s not a absolute path\n \n", keil_prj_path);
        result = -10;
        goto __exit;
    }
    else if (res == -2)
    {
        log_print(_log_file, "\n[ERROR] relative paths go up more levels than absolute paths\n \n");
        result = -11;
        goto __exit;
    }

    snprintf(file_path, file_path_size, "%s%s.map", file_path, uvprojx_file.output_name);
    log_save(_log_file, "[map file path] %s\n", file_path);

    res = map_file_process(file_path, 
                           &load_region_head, 
                           &object_info_head, 
                           uvprojx_file.is_has_user_lib,
                           true);   /* !uvprojx_file.is_custom_scatter */
    if (res == -1)
    {
        log_print(_log_file, "\n[ERROR] Check if a map file exists (Options for Target -> Listing -> Linker Listing)\n");
        log_print(_log_file, "[ERROR] map file path: %s\n", file_path);
        result = -12;
        goto __exit;
    }
    else if (res == -2)
    {
        log_print(_log_file, "\n[ERROR] map file does not contain \"%s\"\n", STR_MEMORY_MAP_OF_THE_IMAGE);
        log_print(_log_file, "[ERROR] Please check: %s\n", file_path);
        result = -13;
        goto __exit;
    }
    else if (res == -3)
    {
        log_print(_log_file, "\n[ERROR] map file does not find object's information\n");
        log_print(_log_file, "[ERROR] Please check: %s\n", file_path);
        result = -14;
        goto __exit;
    }

    log_save(_log_file, "\n[region info]\n");
    for (struct load_region *l_region = load_region_head; 
         l_region != NULL; 
         l_region = l_region->next)
    {
        log_save(_log_file, "[load region] %s\n", l_region->name);
        for (struct exec_region *e_region = l_region->exec_region; 
             e_region != NULL; 
             e_region = e_region->next)
        {
            log_save(_log_file, "\t[execution region] %s, 0x%08X, 0x%08X, 0x%08X [memory type] %d [memory ID] %d\n", 
                     e_region->name, e_region->base_addr, e_region->size, 
                     e_region->used_size, e_region->memory_type, e_region->memory_id);
            
            for (struct region_block *block = e_region->zi_block;
                 block != NULL;
                 block = block->next)
            {
                log_save(_log_file, "\t\t[ZI block] addr: 0x%08X, size: 0x%08X (%d)\n", 
                         block->start_addr, block->size, block->size);
            }
            log_save(_log_file, "\n");
        }
    }

    /* 10. 打印用户 object 和用户 library 文件的 flash 和 RAM 占用情况 */
    /* 10.1 将路径绑定到 object info 对应的 path 成员 */
    size_t max_name_len = 0;
    size_t max_path_len = 0;
    for (struct file_path_list *path_temp = _file_path_list_head;
         path_temp != NULL;
         path_temp = path_temp->next)
    {
        for (struct object_info *object_temp = object_info_head;
             object_temp != NULL;
             object_temp = object_temp->next)
        {
            if (path_temp->file_type == OBJECT_FILE_TYPE_LIBRARY)
            {
                if (strcasecmp(object_temp->name, path_temp->old_name) == 0) {
                    object_temp->path = path_temp->path;
                }
            }
            else 
            {
                if (strcasecmp(object_temp->name, path_temp->new_object_name) == 0) {
                    object_temp->path = path_temp->path;
                }
            }
        }

        /* 计算出各个文件名称和相对路径的最长长度 */
        size_t path_len  = strnlen_s(path_temp->path, MAX_PATH);
        size_t name_len1 = strnlen_s(path_temp->old_name, MAX_PATH);
        size_t name_len2 = strnlen_s(path_temp->new_object_name, MAX_PATH);

        if (name_len1 > max_name_len) {
            max_name_len = name_len1;
        }
        if (name_len2 > max_name_len) {
            max_name_len = name_len2;
        }
        if (path_len > max_path_len) {
            max_path_len = path_len;
        }
    }
    log_save(_log_file, "\n[object name max length] %d\n", max_name_len);
    log_save(_log_file, "[object path max length] %d\n", max_path_len);

    /* 打印抓取的 object 名称和路径 */
    log_save(_log_file, "\n[object in map file]\n");
    for (struct object_info *object_temp = object_info_head;
         object_temp != NULL;
         object_temp = object_temp->next)
    {
        log_save(_log_file, "[object name] %s%*s [path] %s\n", 
                 object_temp->name, max_name_len + 1 - strlen(object_temp->name), " ", object_temp->path);
    }

    /* 打印抓取的 keil 工程中的文件名和路径 */
    log_save(_log_file, "\n[file path in keil project]\n");
    for (struct file_path_list *path_list = _file_path_list_head; 
         path_list != NULL; 
         path_list = path_list->next)
    {
        log_save(_log_file, "[old name] %s%*s [type] %d   [path] %s\n", 
                 path_list->old_name, max_name_len + 1 - strlen(path_list->old_name), " ", 
                 path_list->file_type, path_list->path);

        if (strcmp(path_list->object_name, path_list->new_object_name)) {
            log_save(_log_file, "[new name] %s\n", path_list->new_object_name);
        }
    }

    /* 10.2 打开记录文件，打开失败则新建 */
    snprintf(file_path, file_path_size, "%s\\%s-record.txt", _current_dir, APP_NAME);

    bool is_has_record = true;
    FILE *p_file = fopen(file_path, "r");
    if (p_file == NULL)
    {
        p_file = fopen(file_path, "w+");
        if (p_file == NULL)
        {
            log_print(_log_file, "\n[ERROR] can't create log file\n");
            log_print(_log_file, "[ERROR] Please check: %s\n", file_path);
            result = -15;
            goto __exit;
        }
        is_has_record = false;
    }
    fclose(p_file);

    /* 10.3 若存在记录文件，则读取各个文件 flash 和 RAM 占用情况 */
    bool is_has_object = false;
    bool is_has_region = false;
    if (is_has_record)
    {
        record_file_process(file_path, 
                            &record_load_region_head, 
                            &record_object_info_head, 
                            &is_has_object,
                            &is_has_region,
                            true);  /* !uvprojx_file.is_custom_scatter */
    }

    if (is_has_record)
    {
        /* 将旧的 object 信息绑定到匹配的新的 object 信息上 */
        for (struct object_info *new_obj_info = object_info_head;
             new_obj_info != NULL;
             new_obj_info = new_obj_info->next)
        {
            for (struct object_info *old_obj_info = record_object_info_head;
                 old_obj_info != NULL;
                 old_obj_info = old_obj_info->next)
            {
                if (strcasecmp(new_obj_info->name, old_obj_info->name) == 0) {
                    new_obj_info->old_object = old_obj_info;
                }
            }
        }

        log_save(_log_file, "\n[record region info]\n");
        /* 将旧的 execution region 绑定到匹配的新的 execution region 上 */
        for (struct load_region *old_load_region = record_load_region_head; 
             old_load_region != NULL; 
             old_load_region = old_load_region->next)
        {
            log_save(_log_file, "[load region] %s\n", old_load_region->name);
            for (struct exec_region *old_exec_region = old_load_region->exec_region; 
                 old_exec_region != NULL; 
                 old_exec_region = old_exec_region->next)
            {
                for (struct load_region *new_load_region = load_region_head; 
                     new_load_region != NULL; 
                     new_load_region = new_load_region->next)
                {
                    for (struct exec_region *new_exec_region = new_load_region->exec_region; 
                         new_exec_region != NULL; 
                         new_exec_region = new_exec_region->next)
                    {
                        if (strcmp(new_exec_region->name, old_exec_region->name) == 0) {
                            new_exec_region->old_exec_region = old_exec_region;
                        }
                    }
                }
                log_save(_log_file, "\t[execution region] %s, 0x%08X, 0x%08X, 0x%08X [type] %d [ID] %d\n", 
                         old_exec_region->name, old_exec_region->base_addr, old_exec_region->size, 
                         old_exec_region->used_size, old_exec_region->memory_type, old_exec_region->memory_id);
            }
        }
    }

    /* 10.4 打印并保存本次编译信息至记录文件 */
    if (uvprojx_file.is_enable_lto == false)
    {
        if (_is_display_object) 
        {
            size_t len = 0;
            if (_is_display_path) 
            {
                if (max_name_len > max_path_len) {
                    len = max_name_len;
                } else {
                    len = max_path_len;
                }
            } 
            else {
                len = max_name_len;
            }
            object_print_process(object_info_head, len, is_has_object);
        }

        /* 保存本次编译信息至记录文件 */
        p_file = fopen(file_path, "w+");
        if (p_file == NULL)
        {
            log_print(_log_file, "\n[ERROR] can't create record file\n");
            log_print(_log_file, "[ERROR] Please check: %s\n", file_path);
            result = -16;
            goto __exit;
        }

        fputs("      Code (inc. data)   RO Data    RW Data    ZI Data      Debug   Object Name\n", p_file);

        for (struct object_info *object_temp = object_info_head;
             object_temp != NULL;
             object_temp = object_temp->next)
        {
            snprintf(_line_text, sizeof(_line_text), 
                     "%10d %10d %10d %10d %10d %10d   %s\n",
                     object_temp->code, 0, object_temp->ro_data, object_temp->rw_data, object_temp->zi_data, 0, object_temp->name);
            fputs(_line_text, p_file);
        }
        fputs(STR_OBJECT_TOTALS "\n\n", p_file);
        fclose(p_file);
    }
    // else {
    //     log_print(_log_file, "[WARNING] Because LTO is enabled, information for each file cannot be displayed\n \n");
    // }
    
    /* 11. 打印总 flash 和 RAM 占用情况，以进度条显示 */
    /* 11.1 算出 execution region name 的最大长度  */
    size_t max_region_name = 0;
    for (struct load_region *l_region = load_region_head; 
         l_region != NULL; 
         l_region = l_region->next)
    {
        for (struct exec_region *e_region = l_region->exec_region; 
             e_region != NULL; 
             e_region = e_region->next)
        {
            size_t len = strnlen_s(e_region->name, 32);
            if (len > max_region_name) {
                max_region_name = len;
            }
        }
    }

    /* 11.2 判断当前的内存打印模式 */
    MEMORY_PRINT_MODE print_mode = MEMORY_PRINT_MODE_0;
    if (uvprojx_file.is_has_pack == false)
    {
    #if defined(ENABLE_REFER_TO_KEIL_DIALOG) && (ENABLE_REFER_TO_KEIL_DIALOG != 0)
        if (_memory_info_head == NULL) {
            print_mode = MEMORY_PRINT_MODE_2;
        } else {
            print_mode = MEMORY_PRINT_MODE_1;
        }
    #else
        if (_memory_info_head && uvprojx_file.is_custom_scatter == false) {
            print_mode = MEMORY_PRINT_MODE_1;
        } else {
            print_mode = MEMORY_PRINT_MODE_2;
        }
    #endif
    }
    log_save(_log_file, "[memory print mode]: %d\n", print_mode);

    /* 11.3 开始打印 */
    memory_numbering(MEMORY_TYPE_RAM);
    memory_numbering(MEMORY_TYPE_FLASH);

    if (_is_has_unused_region
    &&  print_mode == MEMORY_PRINT_MODE_0)
    {
        log_print(_log_file, UNUSED_LOAD_REGION_NAME "\n");

        memory_print_unused(MEMORY_TYPE_RAM, max_region_name);
        memory_print_unused(MEMORY_TYPE_FLASH, max_region_name);
        log_print(_log_file, " \n");
    }
    
    bool is_print_null = true;
    for (struct load_region *l_region = load_region_head; 
         l_region != NULL; 
         l_region = l_region->next)
    {
        log_print(_log_file, "%s\n", l_region->name);
        if (print_mode == MEMORY_PRINT_MODE_1)
        {
            memory_mode1_print(l_region->exec_region, MEMORY_TYPE_RAM,     false, max_region_name, is_has_record);
            memory_mode1_print(l_region->exec_region, MEMORY_TYPE_RAM,     true,  max_region_name, is_has_record);
            memory_mode1_print(l_region->exec_region, MEMORY_TYPE_FLASH,   false, max_region_name, is_has_record);
            memory_mode1_print(l_region->exec_region, MEMORY_TYPE_FLASH,   true,  max_region_name, is_has_record);
            memory_mode1_print(l_region->exec_region, MEMORY_TYPE_UNKNOWN, false, max_region_name, is_has_record);
        }
        else if (print_mode == MEMORY_PRINT_MODE_2)
        {
            memory_mode2_print(l_region->exec_region, max_region_name, is_has_record);
        }
        else 
        {
            memory_mode0_print(l_region->exec_region, l_region->name, MEMORY_TYPE_RAM,     max_region_name, is_has_record, is_print_null);
            memory_mode0_print(l_region->exec_region, l_region->name, MEMORY_TYPE_FLASH,   max_region_name, is_has_record, is_print_null);
            memory_mode0_print(l_region->exec_region, l_region->name, MEMORY_TYPE_UNKNOWN, max_region_name, is_has_record, is_print_null);
        }
        is_print_null = false;
    }

    /* 12. 打印栈使用情况 */
    if (uvprojx_file.output_path[0] != '\0')
    {
        res = combine_path(file_path, file_path_size, keil_prj_path, uvprojx_file.output_path);
        if (res == -1)
        {
            log_print(_log_file, "\n[ERROR] %s not a absolute path\n \n", keil_prj_path);
            result = -17;
            goto __exit;
        }
        else if (res == -2)
        {
            log_print(_log_file, "\n[ERROR] relative paths go up more levels than absolute paths\n \n");
            result = -18;
            goto __exit;
        }
        snprintf(file_path, file_path_size, "%s%s.htm", file_path, uvprojx_file.output_name);
        log_save(_log_file, "[htm file path] %s\n", file_path);
        stack_print_process(file_path);
    }

    /* 13. 保存本次 region 信息至记录文件 */
    snprintf(file_path, file_path_size, "%s\\%s-record.txt", _current_dir, APP_NAME);

    if (uvprojx_file.is_enable_lto) {
        p_file = fopen(file_path, "w+");
    } else {
        p_file = fopen(file_path, "a");
    }
    if (p_file == NULL)
    {
        log_print(_log_file, "\n[ERROR] can't create record file\n");
        log_print(_log_file, "[ERROR] Please check: %s\n", file_path);
        result = -19;
        goto __exit;
    }

    fputs(STR_MEMORY_MAP_OF_THE_IMAGE "\n\n", p_file);

    for (struct load_region *l_region = load_region_head; 
         l_region != NULL; 
         l_region = l_region->next)
    {
        snprintf(_line_text, sizeof(_line_text),
                 "\t%s %s \n\n",
                 STR_LOAD_REGION, l_region->name);
        fputs(_line_text, p_file);

        for (struct exec_region *e_region = l_region->exec_region; 
             e_region != NULL; 
             e_region = e_region->next)
        {
            snprintf(_line_text, sizeof(_line_text),
                     "\t\t%s %s (%s0x%08X, %s0x%08X, %s0x%08X, END)\n\n",
                     STR_EXECUTION_REGION, e_region->name, STR_EXECUTE_BASE_ADDR, e_region->base_addr,
                     STR_REGION_USED_SIZE, e_region->used_size, STR_REGION_MAX_SIZE, e_region->size);
            fputs(_line_text, p_file);
        }
    }
    fputs(STR_IMAGE_COMPONENT_SIZE, p_file);
    fclose(p_file);
    
__exit:
    if (_current_dir) {
        free(_current_dir);
    }
    if (file_path) {
        free(file_path);
    }
    object_info_free(&object_info_head);
    object_info_free(&record_object_info_head);
    load_region_free(&load_region_head);
    load_region_free(&record_load_region_head);

    file_path_free(&_file_path_list_head);
    memory_info_free(&_memory_info_head);
    prj_path_list_free(_keil_prj_path_list);
    log_print(_log_file, "=============================================================================================================================\n\n");
    log_save(_log_file, "run time: %.3f s\n", (double)(clock() - run_time) / CLOCKS_PER_SEC);
    fclose(_log_file);
    return result;
}


/**
 * @brief  入口参数处理
 * @note   
 * @param  param_qty:   参数数量
 * @param  param[]:     参数列表
 * @param  prj_name:    [out] keil 工程名
 * @param  name_size:   prj_name 的最大 size
 * @param  prj_path:    [out] keil 工程绝对路径
 * @param  path_size:   prj_path 的最大 size
 * @param  err_param:   [out] 发生错误的参数位
 * @retval 0: 正常 | -x: 错误
 */
int parameter_process(int    param_qty,
                      char   *param[], 
                      char   *prj_name,
                      size_t name_size,
                      char   *prj_path,
                      size_t path_size,
                      int    *err_param)
{
    for (size_t i = 1; i < param_qty; i++)
    {
        log_save(_log_file, "[param %d] %s\n", i, param[i]);

        if (param[i][0] == '-') 
        {
            int seq = 0;
            if (strcasecmp(param[i], _command_list[seq++].cmd) == 0) {
                _is_save_log = false;
            }
            else if (strcasecmp(param[i], _command_list[seq++].cmd) == 0) {
                _is_display_object = true;
            }
            else if (strcasecmp(param[i], _command_list[seq++].cmd) == 0) {
                _is_display_object = false;
            }
            else if (strcasecmp(param[i], _command_list[seq++].cmd) == 0) {
                _is_display_path = true;
            }
            else if (strcasecmp(param[i], _command_list[seq++].cmd) == 0) {
                _is_display_path = false;
            }
            else if (strcasecmp(param[i], _command_list[seq++].cmd) == 0) {
                _progress_style = PROGRESS_STYLE_0;
            }
            else if (strcasecmp(param[i], _command_list[seq++].cmd) == 0) {
                _progress_style = PROGRESS_STYLE_1;
            }
            else if (strcasecmp(param[i], _command_list[seq++].cmd) == 0) {
                _progress_style = PROGRESS_STYLE_2;
            }
            else if (strcasecmp(param[i], "-H")    == 0
            ||       strcasecmp(param[i], "-HELP") == 0) {
                return -4;
            }
            else
            {
                *err_param = i;
                return -3;
            }
        }
        else 
        {
            char *last_slash = NULL;
            size_t param_len = strnlen_s(param[i], MAX_PATH);

            /* 绝对路径 */
            if (param[i][1] == ':')
            {
                DWORD attributes = GetFileAttributes(param[i]);
                if (attributes == INVALID_FILE_ATTRIBUTES) {
                    return -1;
                }

                /* 目录 */
                if (attributes & FILE_ATTRIBUTE_DIRECTORY)
                {
                    strncpy_s(_current_dir, sizeof(_current_dir), param[i], param_len);

                    if (param[i][param_len - 1] == '\\') {
                        _current_dir[param_len - 1] = '\0';
                    }
                }
                /* 文件 */
                else
                {
                    /* 不是 keil 工程则报错退出 */
                    if (is_keil_project(param[i]) == false) {
                        return -2;
                    }
                    strncpy_s(prj_path, path_size, param[i], param_len);

                    last_slash = strrchr(prj_path, '\\');
                    if (last_slash)
                    {
                        last_slash += 1;
                        strncpy_s(prj_name, name_size, last_slash, strnlen(last_slash, name_size));
                    }
                }
            }
            /* 不支持相对路径 */
            else if (param[i][0] == '\\' || param[i][0] == '.') {
                return -2;
            }
            /* 文件名 */
            else
            {
                snprintf(prj_path, path_size, "%s\\%s", _current_dir, param[i]);

                /* 非 keil 工程则检查是否有扩展名 */
                if (is_keil_project(param[i]) == false)
                {
                    /* 有扩展名报错退出，无扩展名则从搜索到的列表里进行匹配 */
                    char *dot = strrchr(param[i], '.');
                    if (dot) {
                        return -2;
                    }

                    for (size_t index = 0; index < _keil_prj_path_list->size; index++) 
                    {
                        if (strstr(_keil_prj_path_list->items[index], param[i])) 
                        {
                            strncpy_s(prj_path, path_size, _keil_prj_path_list->items[index], strnlen_s(_keil_prj_path_list->items[index], MAX_PATH));
                            break;
                        }
                    }
                }

                last_slash = strrchr(prj_path, '\\');
                if (last_slash)
                {
                    last_slash += 1;
                    strncpy_s(prj_name, name_size, last_slash, strnlen(last_slash, name_size));
                }
            }
        }
    }

    return 0;
}


/**
 * @brief  uvoptx 文件处理
 * @note   获取指定的 target name
 * @param  file_path:   uvoptx 文件路径
 * @param  target_name: [out] keil target name
 * @param  max_size:    target_name 的最大 size
 * @retval true: 成功 | false: 失败
 */
bool uvoptx_file_process(const char *file_path, 
                         char *target_name,
                         size_t max_size)
{
    FILE *p_file = fopen(file_path, "r");
    if (p_file == NULL) {
        return false;
    }

    uint8_t state = 0;
    while (fgets(_line_text, sizeof(_line_text), p_file))     
    { 
        char *str;
        switch (state)
        {
            case 0:
                str = strstr(_line_text, LABEL_TARGET_NAME);
                if (str)
                {
                    str += strlen(LABEL_TARGET_NAME);
                    char *lt = strrchr(_line_text, '<');
                    if (lt) 
                    {
                        *lt = '\0';
                        strncpy_s(target_name, max_size, str, strnlen_s(str, max_size));
                        log_save(_log_file, "[target name] %s\n", target_name);
                        state = 1;
                    }
                }
                break;
            case 1:
                str = strstr(_line_text, LABEL_IS_CURRENT_TARGET);
                if (str)
                {
                    str += strlen(LABEL_IS_CURRENT_TARGET);
                    if (*str == '0') {
                        state = 0;
                    } else {
                        state = 2;
                    }
                }
                break;
            default: break;
        }
        if (state == 2) 
        {
            log_save(_log_file, "[final target name] %s\n", target_name);
            break;
        }
    }
    fclose(p_file);

    return true;
}


/**
 * @brief  uvprojx 文件处理
 * @note   获取 uvprojx 文件中的信息
 * @param  file_path:           uvprojx 文件的绝对路径
 * @param  target_name:         指定的 target name
 * @param  out_info:            [out] 解析出的 uvprojx 信息
 * @param  is_get_target_name:  是否获取 target name
 * @retval 0: 成功 | -x: 失败
 */
int uvprojx_file_process(const char *file_path, 
                         const char *target_name,
                         struct uvprojx_info *out_info,
                         bool is_get_target_name)
{
    /* 打开同名的 .uvprojx 或 .uvproj 文件 */
    FILE *p_file = fopen(file_path, "r");
    if (p_file == NULL) {
        return -1;
    }

    char *str     = NULL;
    char *lt      = NULL;
    uint8_t state = 0;
    long mem_pos  = 0;

    /* 逐行读取 */
    while (fgets(_line_text, sizeof(_line_text), p_file))     
    { 
        switch (state)
        {
            case 0:
                str = strstr(_line_text, target_name);
                if (str) 
                {
                    if (is_get_target_name)
                    {
                        str += strlen(LABEL_TARGET_NAME);
                        lt   = strrchr(_line_text, '<');
                        if (lt) 
                        {
                            *lt = '\0';
                            strncpy_s(out_info->target_name, sizeof(out_info->target_name), str, strnlen_s(str, sizeof(out_info->target_name)));
                        }
                    }
                    state = 1;
                }
                break;
            case 1:
                str = strstr(_line_text, LABEL_DEVICE);
                if (str)
                {
                    str += strlen(LABEL_DEVICE);
                    lt   = strrchr(_line_text, '<');
                    if (lt) 
                    {
                        *lt = '\0';
                        strncpy_s(out_info->chip, sizeof(out_info->chip), str, strnlen_s(str, sizeof(out_info->chip)));
                        state = 2;
                    }
                }
                break;
            case 2:
                str = strstr(_line_text, LABEL_VENDOR);
                if (str)
                {
                    str += strlen(LABEL_VENDOR);
                    if (strncasecmp(str, "ARM", 3) == 0) 
                    {
                        out_info->is_has_pack = false;
                        state = 4;
                    } 
                    else 
                    {
                        out_info->is_has_pack = true;
                        state = 3;
                    }
                }
                break;
            case 3:
                bool is_get_first    = false;
                char *str_p1         = NULL;
                char *str_p2         = NULL;
                char *end_ptr        = NULL;
                char name[MAX_PRJ_NAME_SIZE] = {0};
                uint32_t base_addr   = 0;
                uint32_t size        = 0;
                size_t mem_id        = UNKNOWN_MEMORY_ID;
                MEMORY_TYPE mem_type = MEMORY_TYPE_NONE;

                /* 获取 RAM 和 ROM  */
                str = strstr(_line_text, LABEL_CPU);
                if (str)
                {
                    strtok(_line_text, " ");
                    while (1)
                    {
                        if (is_get_first == false) 
                        {
                            str_p1  = strstr(_line_text, LABEL_CPU);
                            str_p1 += strlen(LABEL_CPU);
                            is_get_first = true;
                        }
                        else 
                        {
                            str_p1 = strtok(NULL, " ");
                            if (str_p1 == NULL)
                            {
                                state = 3;
                                break;
                            }
                        }

                        str_p2  = strstr(str_p1, "(");
                        *str_p2 = '\0';
                        strncpy_s(name, sizeof(name), str_p1, strnlen_s(str_p1, sizeof(name)));

                        mem_type = MEMORY_TYPE_UNKNOWN;
                        if (strstr(name, "RAM")) {
                            mem_type = MEMORY_TYPE_RAM;
                        } 
                        else if (strstr(name, "ROM")) {
                            mem_type = MEMORY_TYPE_FLASH;
                        }
                        else 
                        {
                            state = 4;
                            break;
                        }

                        str_p1  = str_p2 + 1;
                        str_p2 += 3;
                        while ((*str_p2 >= '0') && (*str_p2 <= 'F')) {
                            str_p2 += 1;
                        } 

                        uint8_t parse_mode = 0;
                        if (*str_p2 == ',') {
                            parse_mode = 0;
                        } 
                        else if (*str_p2 == '-') {
                            parse_mode = 1;
                        } 
                        else {
                            return -2;
                        }

                        *str_p2   = '\0';
                        base_addr = strtoul(str_p1, &end_ptr, 16); 

                        str_p1    = str_p2 + 1;
                        str_p2    = strstr(str_p1, ")");
                        *str_p2   = '\0';
                        size      = strtoul(str_p1, &end_ptr, 16);

                        if (parse_mode == 1) 
                        {
                            size -= base_addr;
                            size += 1;
                        }

                        if (mem_type == MEMORY_TYPE_UNKNOWN) {
                            memory_info_add(&_memory_info_head, name, 1, base_addr, size, mem_type, true, true);
                        } 
                        else 
                        {
                            mem_id++;
                            memory_info_add(&_memory_info_head, name, mem_id, base_addr, size, mem_type, false, true);
                        }
                    }
                }
                break;
            case 4:
                str = strstr(_line_text, LABEL_OUTPUT_DIRECTORY);
                if (str)
                {
                    str += strlen(LABEL_OUTPUT_DIRECTORY);
                    lt   = strrchr(_line_text, '<');
                    if (lt) 
                    {
                        *lt = '\0';
                        strncpy_s(out_info->output_path, sizeof(out_info->output_path), str, strnlen_s(str, sizeof(out_info->output_path)));
                        state = 5;
                    }
                }
                break;
            case 5:
                str = strstr(_line_text, LABEL_OUTPUT_NAME);
                if (str)
                {
                    str += strlen(LABEL_OUTPUT_NAME);
                    lt   = strrchr(_line_text, '<');
                    if (lt) 
                    {
                        *lt = '\0';
                        strncpy_s(out_info->output_name, sizeof(out_info->output_name), str, strnlen_s(str, sizeof(out_info->output_name)));
                        state = 6;
                    }
                }
                break;
            case 6:
                str = strstr(_line_text, LABEL_LISTING_PATH);
                if (str)
                {
                    str += strlen(LABEL_LISTING_PATH);
                    lt   = strrchr(_line_text, '<');
                    if (lt) 
                    {
                        *lt = '\0';
                        strncpy_s(out_info->listing_path, sizeof(out_info->listing_path), str, strnlen_s(str, sizeof(out_info->listing_path)));
                        state = 7;
                    }
                }
                break;
            case 7:
                /* 检查是否生成了 map 文件 */
                str = strstr(_line_text, LABEL_IS_CREATE_MAP);
                if (str)
                {
                    str += strlen(LABEL_IS_CREATE_MAP);
                    if (*str == '0') {
                        return -3;
                    } 
                    else 
                    {
                        /* 没有 pack 就读取自定义的 memory area */
                        if (out_info->is_has_pack == false || _memory_info_head == NULL) {
                            state = 8;
                        } else {
                            state = 9;
                        }
                        mem_pos = ftell(p_file);
                    }
                }
                break;
            case 8:
                /* 读取自定义 memory area */
                if (memory_area_process(_line_text, false) == false) {
                    state = 9;
                }
                break;
            case 9:
                /* 检查是否开启了 LTO */
                if (({str = strstr(_line_text, LABEL_AC6_LTO); str;}))
                {
                    str += strlen(LABEL_AC6_LTO);
                    if (*str == '0') {
                        out_info->is_enable_lto = false;
                    } else {
                        out_info->is_enable_lto = true;
                    }
                    state = 10;
                }
                else if (({str = strstr(_line_text, LABEL_END_CADS); str;}))
                {
                    out_info->is_enable_lto = false;
                    state = 10;
                }
                break;
            case 10:
                /* 读取是否使用了 keil 生成的 scatter file */
                str = strstr(_line_text, LABEL_IS_KEIL_SCATTER);
                if (str)
                {
                    str += strlen(LABEL_IS_KEIL_SCATTER);
                    if (*str == '0') 
                    {
                        out_info->is_custom_scatter = true;
                        fseek(p_file, mem_pos, SEEK_SET);
                        state = 11;
                    }
                    else 
                    {
                        out_info->is_custom_scatter = false;
                        state = 12;
                    }
                }
                else if (strstr(_line_text, LABEL_END_LDADS)) {
                    state = 12;
                }
                break;
            case 11:
                /* 将新的 memory area 加入 memory info 中 */
                if (memory_area_process(_line_text, true) == false) {
                    state = 12;
                }
                break;
            case 12:
                /* 获取已加入编译的文件路径，并记录重复的文件名 */
                if (file_path_process(_line_text, &out_info->is_has_user_lib) == false) {
                    state = 13;
                }
                break;
            default: break;
        }
        if (state == 13) {
            break;
        }
    }
    fclose(p_file);

    return true;
}


/**
 * @brief  读取 build_log 文件，获取文件的改名信息
 * @note   
 * @param  file_path: build_log 文件所在的路径
 * @retval 
 */
void build_log_file_process(const char *file_path)
{
    FILE *p_file = fopen(file_path, "r");
    if (p_file == NULL) {
        return;
    }

    char *ptr = NULL;
    log_save(_log_file, "\n");

    while (fgets(_line_text, sizeof(_line_text), p_file))
    {
        if (({ptr = strstr(_line_text, STR_RENAME_MARK); ptr;}))
        {
            log_save(_log_file, "%s", _line_text);

            char *str_p1 = strstr(_line_text, "'");
            str_p1 += 1;
            char *str_p2 = strstr(str_p1, "'");
            *str_p2 = '\0';

            for (struct file_path_list *path_temp = _file_path_list_head;
                 path_temp != NULL;
                 path_temp = path_temp->next)
            {
                if (strcmp(str_p1, path_temp->path) == 0)
                {
                    char *str_p3 = strrchr(str_p2 + 1, '\'');
                    *str_p3 = '\0';
                    str_p1  = strrchr(str_p2 + 1, '\\');
                    str_p1 += 1;
                    if (path_temp->new_object_name) {
                        free(path_temp->new_object_name);
                    }
                    path_temp->new_object_name = strdup(str_p1);
                    path_temp->is_rename       = false;
                    log_save(_log_file, "'%s' rename to '%s'\n", path_temp->old_name, str_p1);
                }
            }
        }
        else if (({ptr = strstr(_line_text, STR_COMPILING); ptr;})) {
            break;
        }
    }
    log_save(_log_file, "\n");
    fclose(p_file);
    return;
}


/**
 * @brief  文件名重名修改处理
 * @note   
 * @retval None
 */
void file_rename_process(void)
{
    char str[MAX_PRJ_NAME_SIZE] = {0};

    for (struct file_path_list *path_temp1 = _file_path_list_head;
         path_temp1 != NULL;
         path_temp1 = path_temp1->next)
    {
        size_t repeat = 0;

        for (struct file_path_list *path_temp2 = path_temp1->next;
             path_temp2 != NULL;
             path_temp2 = path_temp2->next)
        {
            if (path_temp2->is_rename
            &&  strcmp(path_temp1->object_name, path_temp2->object_name) == 0)
            {
                repeat++;

                strncpy_s(str, sizeof(str), path_temp2->old_name, strnlen_s(path_temp2->old_name, sizeof(str)));
                char *dot = strrchr(str, '.');
                if (dot) {
                    *dot = '\0';
                }
                snprintf(str, sizeof(str), "%s_%d.o", str, repeat);
                if (path_temp2->new_object_name) {
                    free(path_temp2->new_object_name);
                }
                path_temp2->new_object_name = strdup(str);
                path_temp2->is_rename       = false;
                log_save(_log_file, "object '%s' rename to '%s'\n", path_temp2->old_name, str);
            }
        }
    }
}


/**
 * @brief  自定义 memory area 读取
 * @note   
 * @param  str:     读取到的 uvprojx 文件的每一行文本
 * @param  is_new:  是否为新增的 memory area
 * @retval true: 继续 | false: 结束
 */
bool memory_area_process(const char *str, bool is_new)
{
    static uint8_t area  = 0;
    static uint8_t state = 0;
    static uint32_t addr = 0;
    static uint32_t size = 0;
    static size_t mem_id = UNKNOWN_MEMORY_ID;
    static MEMORY_TYPE mem_type = MEMORY_TYPE_NONE;

    if (str == NULL || strstr(str, LABEL_END_ONCHIP_MEMORY))
    {
        area     = 0;
        state    = 0;
        addr     = 0;
        size     = 0;
        mem_id   = UNKNOWN_MEMORY_ID;
        mem_type = MEMORY_TYPE_NONE;
        return false;
    }

    char *str_p1  = NULL;
    char *str_p2  = NULL;
    char *end_ptr = NULL;

    switch (state)
    {
        case 0:
            if (strstr(str, LABEL_ONCHIP_MEMORY)) {
                state = 1;
            }
            break;
        case 1:
            if (strstr(str, LABEL_MEMORY_AREA)) {
                state = 2;
            }
            break;
        case 2:
            str_p1 = strstr(str, LABEL_MEMORY_TYPE);
            if (str_p1)
            {
                str_p1 += strlen(LABEL_MEMORY_TYPE);
                str_p2  = strrchr(str_p1, '<');
                *str_p2 = '\0';

                if (strtoul(str_p1, &end_ptr, 16) == 0) {
                    mem_type = MEMORY_TYPE_RAM;
                } else {
                    mem_type = MEMORY_TYPE_FLASH;
                }
                area++;
                state = 3;
            }
            break;
        case 3:
            str_p1 = strstr(str, LABEL_MEMORY_ADDRESS);
            if (str_p1)
            {
                str_p1 += strlen(LABEL_MEMORY_ADDRESS);
                str_p2  = strrchr(str_p1, '<');
                *str_p2 = '\0';
                addr    = strtoul(str_p1, &end_ptr, 16);
                state   = 4;
            }
            break;
        case 4:
            str_p1 = strstr(str, LABEL_MEMORY_SIZE);
            if (str_p1)
            {
                str_p1 += strlen(LABEL_MEMORY_SIZE);
                str_p2  = strrchr(str_p1, '<');
                *str_p2 = '\0';
                size    = strtoul(str_p1, &end_ptr, 16);

                if (size == 0) {
                    state = 2;
                } else {
                    state = 5;
                }

                if (is_new == false) {
                    break;
                }

                for (struct memory_info *memory = _memory_info_head;
                     memory != NULL;
                     memory = memory->next)
                {
                    if (addr >= memory->base_addr
                    &&  addr <= (memory->base_addr + memory->size))
                    {
                        state = 2;
                        break;
                    }
                }
            }
            break;
        case 5:
            if (strstr(str, LABLE_END_MEMORY_AREA))
            {
                bool is_offchip = true;
                if (area == 4 || area == 5 || area == 9 || area == 10) {
                    is_offchip = false;
                }
                mem_id++;
                memory_info_add(&_memory_info_head, NULL, mem_id, addr, size, mem_type, is_offchip, false);
                state = 2;
            }
            break;
        default: break;
    }
    return true;
}


/**
 * @brief  文件路径处理
 * @note   获取 uvprojx 文件中被添加进 keil 工程的文件及其相对路径
 * @param  str:             读取到的 uvprojx 文件的每一行文本
 * @param  is_has_user_lib: [out] 是否有 user lib
 * @retval true: 继续 | false: 结束
 */
bool file_path_process(const char *str, bool *is_has_user_lib)
{
    static uint8_t state = 0;
    static char path[MAX_PATH] = {0};
    static char name[MAX_PRJ_NAME_SIZE] = {0};
    static OBJECT_FILE_TYPE type = OBJECT_FILE_TYPE_USER;

    char *str_p1 = NULL;
    char *str_p2 = NULL;

    if (strstr(str, LABEL_END_GROUPS)) 
    {
        state = 0;
        return false;
    }

    switch (state)
    {
        case 0:
            if (strstr(str, LABEL_GROUP_NAME)) {
                state = 1;
            }
            break;
        case 1:
            if (({str_p1 = strstr(str, LABEL_FILE_NAME); str_p1;})) 
            {
                str_p1 += strlen(LABEL_FILE_NAME);
                str_p2  = strrchr(str_p1, '<');
                *str_p2 = '\0';
                strncpy_s(name, sizeof(name), str_p1, strnlen_s(str_p1, sizeof(name)));
                type  = OBJECT_FILE_TYPE_USER;
                state = 2;
            }
            else if (({str_p1 = strstr(str, LABEL_INCLUDE_IN_BUILD); str_p1;}))
            {
                str_p1 += strlen(LABEL_INCLUDE_IN_BUILD);
                if (*str_p1 == '0') {
                    state = 0;
                }
            }
            else if (strstr(str, LABEL_END_FILES)) {
                state = 0;
            }
            break;
        case 2:
            str_p1 = strstr(str, LABEL_FILE_TYPE);
            if (str_p1) 
            {
                str_p1 += strlen(LABEL_FILE_TYPE);
                /* text document file or custom file */
                if (*str_p1 == '5' || *str_p1 == '6') {
                    state = 1;
                } 
                else if (*str_p1 == '3')    /* object file */
                {
                    type  = OBJECT_FILE_TYPE_OBJECT;
                    state = 3;
                }
                else if (*str_p1 == '4')    /* library file */
                {
                    *is_has_user_lib = true;
                    type  = OBJECT_FILE_TYPE_LIBRARY;
                    state = 3;
                }
                else {
                    state = 3;
                }
            }
            break;
        case 3:
            str_p1 = strstr(str, LABEL_FILE_PATH);
            if (str_p1) 
            {
                str_p1 += strlen(LABEL_FILE_PATH);
                str_p2  = strrchr(str_p1, '<');
                *str_p2 = '\0';
                strncpy_s(path, sizeof(path), str_p1, strnlen_s(str_p1, sizeof(path)));
                state = 4;
            }
            break;
        case 4:
            if (strstr(str, LABEL_END_FILE)) 
            {
                file_path_add(&_file_path_list_head, name, path, type);
                state = 1;
            }
            else if (({str_p1 = strstr(str, LABEL_INCLUDE_IN_BUILD); str_p1;}))
            {
                str_p1 += strlen(LABEL_INCLUDE_IN_BUILD);
                if (*str_p1 != '0') {
                    file_path_add(&_file_path_list_head, name, path, type);
                }
                state = 1;
            }
            break;
        default: break;
    }

    return true;
}


/**
 * @brief  map 文件处理
 * @note   获取 map 文件中每个编译文件的信息
 * @param  file_path:       map 文件的绝对路径
 * @param  region_head:     region 链表头
 * @param  object_head:     object 文件链表头
 * @param  is_has_user_lib: 是否获取 user lib 信息
 * @param  is_match_memory: 是否要匹配存储器信息
 * @retval 0: 正常 | -x: 错误
 */
int map_file_process(const char *file_path, 
                     struct load_region **region_head,
                     struct object_info **object_head,
                     bool is_get_user_lib,
                     bool is_match_memory)
{
    FILE *p_file = fopen(file_path, "r");
    if (p_file == NULL) {
        return -1;
    }

    /* 读取 map 文件 */
    fseek(p_file, 0, SEEK_END);
    long pos_head = ftell(p_file);
    long pos_end  = pos_head;
    long memory_map_pos = 0;

    /* 从文件末尾开始逆序读取 */
    while (pos_head)
    {
        fseek(p_file, pos_head, SEEK_SET);
        if (fgetc(p_file) == '\n' && (pos_end - pos_head) > 1)
        {
            fseek(p_file, pos_head + 1, SEEK_SET);
            fgets(_line_text, sizeof(_line_text), p_file);
            pos_end = pos_head;

            if (strstr(_line_text, STR_MEMORY_MAP_OF_THE_IMAGE))
            {
                /* 记录位置并退出循环 */
                memory_map_pos = ftell(p_file);
                break;
            }
        }
        pos_head--;
    }

    if (pos_head == 0)
    {
        fclose(p_file);
        return -2;
    }

    /* 获取 map 文件中的 load region 和 execution region 信息 */
    region_info_process(p_file, memory_map_pos, region_head, is_match_memory);

    /* 获取每个 .o 文件的 flash 和 RAM 占用情况 */
    return object_info_process(object_head, p_file, NULL, is_get_user_lib, 0);
}


/**
 * @brief  获取 load region 和 execution region 信息
 * @note   
 * @param  p_file:          文件对象
 * @param  read_start_pos:  开始读取的位置
 * @param  region_head:     region 链表头
 * @param  is_match_memory: 是否要将 region 与 memory 绑定
 * @retval 0: 正常 | -5: 获取失败
 */
int region_info_process(FILE *p_file, 
                        long read_start_pos, 
                        struct load_region **region_head,
                        bool is_match_memory)
{
    /* 先从记录的位置开始正序读取 */
    fseek(p_file, read_start_pos, SEEK_SET);

    bool is_has_load_region = false;
    uint8_t size_pos = 2;
    struct load_region *l_region = NULL;
    struct exec_region *e_region = NULL;
    
    while (fgets(_line_text, sizeof(_line_text), p_file))
    {
        if (strstr(_line_text, STR_IMAGE_COMPONENT_SIZE)) {
            return 0;
        }

        bool is_offchip = false;
        char *str_p1  = NULL;
        char *str_p2  = NULL;
        char *end_ptr = NULL;
        char *load_region_name = NULL;
        char name[MAX_PRJ_NAME_SIZE] = {0};
        uint32_t base_addr = 0;
        uint32_t size      = 0;
        uint32_t used_size = 0;
        size_t memory_id   = 0;
        MEMORY_TYPE memory_type = MEMORY_TYPE_NONE;
        
        str_p1 = strstr(_line_text, STR_LOAD_REGION);
        if (str_p1)
        {
            str_p1 += strlen(STR_LOAD_REGION) + 1;
            str_p2  = strstr(str_p1, " ");
            *str_p2 = '\0';
            strncpy_s(name, sizeof(name), str_p1, strnlen_s(str_p1, sizeof(name)));

            l_region = load_region_create(region_head, name);
            is_has_load_region = true;
        }
        else if (is_has_load_region)
        {
            str_p1 = strstr(_line_text, STR_EXECUTION_REGION);
            if (str_p1)
            {
                if (strstr(_line_text, STR_LOAD_BASE)) {
                    size_pos = 3;
                }

                str_p1 += strlen(STR_EXECUTION_REGION) + 1;
                str_p2  = strstr(str_p1, " ");
                *str_p2 = '\0';
                strncpy_s(name, sizeof(name), str_p1, strnlen_s(str_p1, sizeof(name)));

                str_p1 = strstr(str_p2 + 1, STR_EXECUTE_BASE_ADDR);
                if (str_p1 == NULL)
                {
                    str_p1 = strstr(str_p2 + 1, STR_EXECUTE_BASE);
                    if (str_p1 == NULL) {
                        return -5;
                    }
                    str_p1 += strlen(STR_EXECUTE_BASE);
                }
                else {
                    str_p1 += strlen(STR_EXECUTE_BASE_ADDR);
                }
                
                str_p2    = strstr(str_p1, ",");
                *str_p2   = '\0';
                base_addr = strtoul(str_p1, &end_ptr, 16);

                str_p1    = strstr(str_p2 + 1, STR_REGION_USED_SIZE);
                str_p1   += strlen(STR_REGION_USED_SIZE);
                str_p2    = strstr(str_p1, ",");
                *str_p2   = '\0';
                used_size = strtoul(str_p1, &end_ptr, 16);

                str_p1    = strstr(str_p2 + 1, STR_REGION_MAX_SIZE);
                str_p1   += strlen(STR_REGION_MAX_SIZE);
                str_p2    = strstr(str_p1, ",");
                *str_p2   = '\0';
                size      = strtoul(str_p1, &end_ptr, 16);

                is_offchip  = false;
                memory_id   = UNKNOWN_MEMORY_ID;
                memory_type = MEMORY_TYPE_UNKNOWN;
                load_region_name = NULL;

                if (is_match_memory)
                {
                    /* 将 execution region 与 对应的 memory 绑定  */
                    for (struct memory_info *memory_temp = _memory_info_head;
                         memory_temp != NULL;
                         memory_temp = memory_temp->next)
                    {
                        if (base_addr >= memory_temp->base_addr
                        &&  base_addr < (memory_temp->base_addr + memory_temp->size))
                        {
                            memory_temp->is_used = true;

                            is_offchip  = memory_temp->is_offchip;
                            memory_id   = memory_temp->id;
                            memory_type = memory_temp->type;
                            load_region_name = l_region->name;

                            if (size == UINT32_MAX) {
                                size = memory_temp->size;
                            }
                            break;
                        }
                    }
                }

                region_zi_process(NULL, NULL, 0);
                e_region = load_region_add_exec_region(&l_region,
                                                       name,
                                                       load_region_name,
                                                       memory_id,
                                                       base_addr,
                                                       size,
                                                       used_size,
                                                       memory_type,
                                                       is_offchip);
            }
            else if (e_region 
            &&       e_region->memory_type != MEMORY_TYPE_FLASH
            &&       strstr(_line_text, "0x"))
            {
                region_zi_process(&e_region, _line_text, size_pos);
            }
        }
    }

    return -5;
}


/**
 * @brief  获取 region 中的 zero init 区域块分布
 * @note   e_region 参数传值为 NULL 时将复位本函数。
 *         切换至新的 execution region 前，必须复位本函数
 * @param  e_region:    execution region
 * @param  text:        一行文本内容
 * @param  size_pos:    Size 栏目所在的位置，从 1 算起
 * @retval None
 */
void region_zi_process(struct exec_region **e_region,
                       char *text,
                       size_t size_pos)
{
    static bool is_zi_start = false;
    static uint32_t last_end_addr = 0;
    static struct region_block **zi_block = NULL;

    if (e_region == NULL) 
    {
        zi_block      = NULL;
        is_zi_start   = false;
        last_end_addr = 0;
        return;
    }

    if (strstr(text, STR_ZERO_INIT)) {
        is_zi_start = true;
    }
    else if (strstr(text, STR_PADDING)) 
    { 
        if (is_zi_start == false) {
            return;
        }
    }
    else 
    {
        zi_block      = NULL;
        is_zi_start   = false;
        last_end_addr = 0;
        return;
    }

    char *addr_token = strtok(text, " ");
    for (size_t i = 2; i < size_pos; i++) {
        strtok(NULL, " ");
    }
    char *size_token = strtok(NULL, " ");

    char *end_ptr = NULL;
    uint32_t addr = strtoul(addr_token, &end_ptr, 16);
    uint32_t size = strtoul(size_token, &end_ptr, 16);

    if (addr > last_end_addr) 
    {
        zi_block = &(*e_region)->zi_block;

        if (*zi_block)
        {
            struct region_block *block = *zi_block;

            while (block->next) {
                block = block->next;
            }
            zi_block = &block->next;
        }

        *zi_block = (struct region_block *)malloc(sizeof(struct region_block));
        (*zi_block)->start_addr = addr;
        (*zi_block)->size       = size;
        (*zi_block)->next       = NULL;
    }
    else if (*zi_block) {
        (*zi_block)->size += size;
    }

    last_end_addr = addr + size;
}


/**
 * @brief  获取 object info
 * @note   
 * @param  object_head:     object 文件链表头
 * @param  p_file:          文件对象
 * @param  end_pos:         [out] 最后读取到的文件位置
 * @param  is_get_user_lib: 是否获取用户 lib 信息
 * @param  parse_mode:      解析模式 0: 按 map 文件解析 | 1: 按 record 文件解析
 * @retval 0: 正常 | -x: 错误
 */
int object_info_process(struct object_info **object_head,
                        FILE *p_file,
                        long *end_pos,
                        bool is_get_user_lib,
                        uint8_t parse_mode)
{
    int result     = 0;
    uint8_t state  = 0;
    uint32_t value[16] = {0};
    char name[MAX_PRJ_NAME_SIZE] = {0};
    char *token    = NULL;
    char *end_ptr  = NULL;
    char *new_line = NULL;
    size_t index   = 0;

    /* 获取用户文件的 object info */
    while (fgets(_line_text, sizeof(_line_text), p_file))
    {
        switch (state)
        {
            case 0:
                if (parse_mode == 0)
                {
                    /* Object Name 全部添加 */
                    if (strstr(_line_text, ".o")) 
                    {
                        index = 0;
                        /* 切割后转换 */
                        token = strtok(_line_text, " ");
                        while (token != NULL)
                        {
                            if (index < OBJECT_INFO_STR_QTY - 1) {
                                value[index] = strtoul(token, &end_ptr, 10);
                            } 
                            else    /* 最后一个是名称 */
                            {
                                new_line = strrchr(token, '\n');
                                if (new_line) {
                                    *new_line = '\0';
                                }
                                strncpy_s(name, sizeof(name), token, strnlen_s(token, sizeof(name)));
                            }
                            if (++index == OBJECT_INFO_STR_QTY) {
                                break;
                            }
                            token = strtok(NULL, " ");
                        }

                        /* 保存 */
                        if (index == OBJECT_INFO_STR_QTY) {
                            object_info_add(object_head, name, value[0], value[2], value[3], value[4]);
                        } 
                        else 
                        {
                            result = -3;
                            break;
                        }
                    }
                    else if (strstr(_line_text, STR_LIBRARY_MEMBER_NAME)) 
                    {
                        if (is_get_user_lib) {
                            state = 1;
                        } else {
                            state = 3;
                        }
                    }
                }
                else if (parse_mode == 1)
                {
                    if (strstr(_line_text, STR_OBJECT_NAME)) {
                        state = 2;
                    }
                }
                break;
            case 1:
                /* Library Member Name 仅添加匹配的 object */
                if (strstr(_line_text, ".o")) 
                {
                    index = 0;
                    /* 切割后转换 */
                    token = strtok(_line_text, " ");
                    while (token != NULL)
                    {
                        if (index < OBJECT_INFO_STR_QTY - 1) {
                            value[index] = strtoul(token, &end_ptr, 10);
                        } 
                        else    /* 最后一个是名称 */
                        {
                            new_line = strrchr(token, '\n');
                            if (new_line) {
                                *new_line = '\0';
                            }
                            strncpy_s(name, sizeof(name), token, strnlen_s(token, sizeof(name)));
                        }
                        if (++index == OBJECT_INFO_STR_QTY) {
                            break;
                        }
                        token = strtok(NULL, " ");
                    }

                    /* 保存 */
                    if (index == OBJECT_INFO_STR_QTY) 
                    {
                        for (struct file_path_list *path_temp = _file_path_list_head; 
                             path_temp != NULL; 
                             path_temp = path_temp->next)
                        {
                            if (path_temp->file_type == OBJECT_FILE_TYPE_LIBRARY)
                            {
                                if (strcasecmp(name, path_temp->new_object_name) == 0) 
                                {
                                    object_info_add(object_head, name, value[0], value[2], value[3], value[4]);
                                    break;
                                }
                            }
                        }
                    }
                }
                else if (strstr(_line_text, STR_LIBRARY_NAME)) {
                    state = 2;
                }
                break;
            case 2:
                /* Library Member Name 仅添加匹配的 object */
                if (strstr(_line_text, STR_OBJECT_TOTALS)) 
                {
                    state = 3;
                    break;
                }
                else
                {
                    index = 0;
                    /* 切割后转换 */
                    token = strtok(_line_text, " ");
                    while (token != NULL)
                    {
                        if (index < OBJECT_INFO_STR_QTY - 1) {
                            value[index] = strtoul(token, &end_ptr, 10);
                        } 
                        else    /* 最后一个是名称 */
                        {
                            new_line = strrchr(token, '\n');
                            if (new_line) {
                                *new_line = '\0';
                            }
                            strncpy_s(name, sizeof(name), token, strnlen_s(token, sizeof(name)));
                        }
                        if (++index == OBJECT_INFO_STR_QTY) {
                            break;
                        }
                        token = strtok(NULL, " ");
                    }

                    /* 保存 */
                    if (index == OBJECT_INFO_STR_QTY) 
                    {
                        if (parse_mode == 1)
                        {
                            object_info_add(object_head, name, value[0], value[2], value[3], value[4]);
                            break;
                        }

                        for (struct file_path_list *path_temp = _file_path_list_head; 
                             path_temp != NULL; 
                             path_temp = path_temp->next)
                        {
                            if (path_temp->file_type == OBJECT_FILE_TYPE_LIBRARY)
                            {
                                if (strcasecmp(name, path_temp->old_name) == 0) 
                                {
                                    object_info_add(object_head, name, value[0], value[2], value[3], value[4]);
                                    break;
                                }
                            }
                        }
                    }
                }
                break;
            default: break;
        }

        if (state == 3 || result != 0) {
            break;
        }
    }

    if (state == 3) 
    {
        if (end_pos) {
            *end_pos = ftell(p_file);
        }
    }
    fclose(p_file);
    return result;
}


/**
 * @brief  记录文件处理
 * @note   
 * @param  file_path:       文件的绝对路径
 * @param  region_head:     region 链表头
 * @param  object_head:     object 文件链表头
 * @param  is_has_object:   [out] 是否存在 object 信息
 * @param  is_has_region:   [out] 是否存在 region 信息
 * @param  is_match_memory: 是否要将 region 与 memory 绑定
 * @retval 0: 正常 | -x: 错误
 */
int record_file_process(const char *file_path, 
                        struct load_region **region_head,
                        struct object_info **object_head,
                        bool *is_has_object,
                        bool *is_has_region,
                        bool is_match_memory)
{
    *is_has_object = false;
    *is_has_region = false;

    FILE *p_file = fopen(file_path, "r");
    if (p_file == NULL) {
        return -1;
    }

    long end_pos = 0;
    int result = object_info_process(object_head, p_file, &end_pos, false, 1);
    if (result == 0) {
        *is_has_object = true;
    }

    p_file = fopen(file_path, "r");
    if (p_file == NULL) {
        return -1;
    }
    result = region_info_process(p_file, end_pos, region_head, is_match_memory);
    if (result == 0) {
        *is_has_region = true;
    }

    return result;
}


/**
 * @brief  object 信息打印处理
 * @note   
 * @param  object_head:     object 文件链表头
 * @param  max_path_len:    最大路径长度
 * @param  is_has_record:   是否有记录文件
 * @retval None
 */
void object_print_process(struct object_info *object_head,
                          size_t max_path_len, 
                          bool is_has_record)
{
    if ((max_path_len + 2) < strlen(STR_FILE)) {
        max_path_len = strlen(STR_FILE);
    }

    size_t len = max_path_len + 2 - strlen(STR_FILE);
    if (_is_display_path) {
        len += strlen("():");
    }

    size_t left_space  = len / 2;
    size_t right_space = left_space;
    if (len % 2) {
        left_space += 1;
    } 

    snprintf(_line_text, sizeof(_line_text), 
             "%*s%s%*s|         RAM (byte)       |       FLASH (byte)       |\n", 
             left_space, " ", STR_FILE, right_space, " ");

    len = strnlen_s(_line_text, sizeof(_line_text));
    char *line = (char *)malloc(len);
    size_t i = 0;
    for (; i < len - 1; i++) {
        line[i] = '-';
    }
    line[i] = '\0';
    log_print(_log_file, "%s\n", line);
    log_print(_log_file, "%s", _line_text);
    log_print(_log_file, "%s\n", line);
    
    for (struct object_info *obj_info = object_head; 
         obj_info != NULL; 
         obj_info = obj_info->next)
    {
        if (obj_info->path == NULL) {
            continue;
        }

        char *path        = obj_info->path;
        char ram_text[MAX_PRJ_NAME_SIZE]   = {0};
        char flash_text[MAX_PRJ_NAME_SIZE] = {0};
        size_t path_len   = strnlen_s(obj_info->path, MAX_PATH);
        size_t path_space = max_path_len - path_len + 1;
        uint32_t ram      = obj_info->rw_data + obj_info->zi_data;
        uint32_t flash    = obj_info->code + obj_info->ro_data + obj_info->rw_data;

//        if (obj_info->path == NULL || _is_display_path == false) 
        if (_is_display_path == false) 
        {
            path = obj_info->name;
            if (path == NULL) {
                path = "UNKNOWN";
            }
            path_len   = strnlen_s(path, MAX_PATH);
            path_space = max_path_len - path_len + 1;
        }

        if (is_has_record)
        {
            if (obj_info->old_object == NULL)
            {
                strncpy_s(ram_text,   sizeof(ram_text),   "[NEW]     ", 10);
                strncpy_s(flash_text, sizeof(flash_text), "[NEW]     ", 10);
            }
            else
            {
                char ram_sign;
                char flash_sign;
                uint32_t old_ram      = obj_info->old_object->rw_data + obj_info->old_object->zi_data;
                uint32_t old_flash    = obj_info->old_object->code + obj_info->old_object->ro_data + obj_info->old_object->rw_data;
                uint32_t ram_increm   = 0;
                uint32_t flash_increm = 0;

                if (ram < old_ram)
                {
                    ram_increm = old_ram - ram;
                    ram_sign   = '-';
                }
                else
                {
                    ram_increm = ram - old_ram;
                    ram_sign   = '+';
                }

                if (flash < old_flash) 
                {
                    flash_increm = old_flash - flash;
                    flash_sign   = '-';
                }
                else
                {
                    flash_increm = flash - old_flash;
                    flash_sign   = '+';
                }

                char str[MAX_PRJ_NAME_SIZE] = {0};
                size_t str_len   = 0;
                size_t space_len = 0;

                if (ram_increm)
                {
                    snprintf(ram_text, sizeof(ram_text), "[%c%d]", ram_sign, ram_increm);
                    str_len   = strnlen_s(ram_text, sizeof(ram_text));
                    space_len = 10 - str_len;
                    if (space_len)
                    {
                        for (size_t i = 0; i < space_len; i++) {
                            str[i] = ' ';
                        }
                        strncat_s(ram_text, sizeof(ram_text), str, space_len);
                    }
                }
                else {
                    strncpy_s(ram_text, sizeof(ram_text), "          ", 10);
                }

                if (flash_increm)
                {
                    snprintf(flash_text, sizeof(flash_text), "[%c%d]", flash_sign, flash_increm);
                    str_len   = strnlen_s(flash_text, sizeof(flash_text));
                    space_len = 10 - str_len;
                    if (space_len)
                    {
                        for (size_t i = 0; i < space_len; i++) {
                            str[i] = ' ';
                        }
                        strncat_s(flash_text, sizeof(flash_text), str, space_len);
                    }
                }
                else {
                    strncpy_s(flash_text, sizeof(flash_text), "          ", 10);
                }
            }
        }
        else 
        {
            strncpy_s(ram_text,   sizeof(ram_text),   "          ", 10);
            strncpy_s(flash_text, sizeof(flash_text), "          ", 10);
        }

        if (_is_display_path) 
        {
            snprintf(_line_text, sizeof(_line_text), 
                     "%s():%*s |  %10d  %s  |  %10d  %s  |", 
                     path, path_space, " ", ram, ram_text, flash, flash_text);
        }
        else 
        {
            snprintf(_line_text, sizeof(_line_text), 
                     "%s%*s |  %10d  %s  |  %10d  %s  |", 
                     obj_info->name, path_space, " ", ram, ram_text, flash, flash_text);
        }
        log_print(_log_file, "%s\n", _line_text);
    }
    log_print(_log_file, "%s\n", line);
    free(line);
}


/**
 * @brief  为 memory 编号
 * @note   
 * @param  mem_type: 指定编号的内存类型
 * @retval None
 */
void memory_numbering(MEMORY_TYPE mem_type)
{
    size_t id = 1;

    for (struct memory_info *memory = _memory_info_head;
         memory != NULL;
         memory = memory->next)
    {
        if (memory->is_used == false) {
            _is_has_unused_region = true;
        }

        if (memory->type != mem_type) {
            continue;
        }

        memory->mem_id = id++;
    }
}


/**
 * @brief  打印未使用的 memory
 * @note   
 * @param  mem_type:        指定打印的内存类型
 * @param  max_region_name: 最大的 execution region 名称长度
 * @retval None
 */
void memory_print_unused(MEMORY_TYPE mem_type, size_t max_region_name)
{
    for (struct memory_info *memory = _memory_info_head;
         memory != NULL;
         memory = memory->next)
    {
        if (memory->is_used) {
            continue;
        }

        if (memory->type != mem_type) {
            continue;
        }

        if (mem_type == MEMORY_TYPE_RAM) {
            snprintf(_line_text, sizeof(_line_text), "        RAM %d    ", memory->mem_id);
        }
        else if (mem_type == MEMORY_TYPE_FLASH) {
            snprintf(_line_text, sizeof(_line_text), "        FLASH %d  ", memory->mem_id);
        }
        else {
            snprintf(_line_text, sizeof(_line_text), "        UNKNOWN");
        }

        log_print(_log_file, "%s%*s [0x%08X | 0x%08X (%d)]\n",
                  _line_text, max_region_name, " ", memory->base_addr, memory->size, memory->size);
    }
}


/**
 * @brief  模式零打印内存占用情况
 * @note   
 * @param  e_region:         execution region
 * @param  load_region_name: 指定打印的 load region 名称
 * @param  mem_type:         指定打印的 execution region 内存类型
 * @param  max_region_name:  最大的 execution region 名称长度
 * @param  is_has_record:    是否有记录文件
 * @param  is_print_null:    是否打印未使用的存储器
 * @retval None
 */
void memory_mode0_print(struct exec_region *e_region,
                        const char *load_region_name,
                        MEMORY_TYPE mem_type,
                        size_t max_region_name, 
                        bool is_has_record,
                        bool is_print_null)
{
    bool is_print_head = false;
    bool is_print_body = false;
    char str[MAX_PRJ_NAME_SIZE] = {0};

    if (mem_type == MEMORY_TYPE_UNKNOWN) 
    {
        for (struct exec_region *region = e_region;
             region != NULL;
             region = region->next)
        {
            if (region->memory_type == MEMORY_TYPE_UNKNOWN) 
            {
                if (is_print_head == false) 
                {
                    log_print(_log_file, "        UNKNOWN\n");
                    is_print_head = true;
                }
                progress_print(region, max_region_name, is_has_record);
            }
        }
        if (is_print_head) {
            log_print(_log_file, " \n");
        }
        return;
    }

    size_t id = 0;
    bool is_no_region  = true;

    for (struct memory_info *memory = _memory_info_head;
         memory != NULL;
         memory = memory->next)
    {
        if (memory->type != mem_type) {
            continue;
        }

        id++;
        is_no_region  = true;
        is_print_head = false;

        if (mem_type == MEMORY_TYPE_RAM) {
            snprintf(str, sizeof(str), "        RAM %d    ", memory->mem_id);
        }
        else if (mem_type == MEMORY_TYPE_FLASH) {
            snprintf(str, sizeof(str), "        FLASH %d  ", memory->mem_id);
        }

        for (struct exec_region *region = e_region;
             region != NULL;
             region = region->next)
        {
            if (region->used_size == 0) {
                continue;
            }

            if (strcmp(load_region_name, region->load_region_name)) {
                continue;
            }

            if (region->is_printed == false
            &&  memory->id   == region->memory_id
            &&  memory->type == region->memory_type)
            {
                if (is_print_head == false)
                {
                    log_print(_log_file, "%s%*s [0x%08X | 0x%08X (%d)]\n",
                              str, max_region_name, " ", memory->base_addr, memory->size, memory->size);
                    is_print_head = true;
                    is_print_body = true;
                }

                progress_print(region, max_region_name, is_has_record);
                is_no_region = false;
            }
        }

        // if (is_no_region 
        // &&  is_print_null 
        // &&  memory->is_from_pack) 
        // {
        //     log_print(_log_file, "%s%*s [0x%.8X | 0x%.8X (%d)]\n",
        //               str, max_region_name, " ", memory->base_addr, memory->size, memory->size);
        //     log_print(_log_file, "                NULL\n");
        // }
        // else {
        //     log_print(_log_file, " \n");
        // }
    }
    
    if (is_print_body) {
        log_print(_log_file, " \n");
    }
}


/**
 * @brief  模式一打印内存占用情况
 * @note   
 * @param  e_region:        execution region
 * @param  mem_type:        指定打印的 execution region 内存类型
 * @param  is_offchip:      是否为片外 memory
 * @param  max_region_name: 最大的 execution region 名称长度
 * @param  is_has_record:   是否有记录文件
 * @retval None
 */
void memory_mode1_print(struct exec_region *e_region,
                        MEMORY_TYPE mem_type,
                        bool is_offchip,
                        size_t max_region_name, 
                        bool is_has_record)
{
    bool is_print_head = false;
    char str[MAX_PRJ_NAME_SIZE] = {0};

    if (mem_type == MEMORY_TYPE_UNKNOWN) 
    {
        for (struct exec_region *region = e_region;
             region != NULL;
             region = region->next)
        {
            if (region->memory_type == MEMORY_TYPE_UNKNOWN) 
            {
                if (is_print_head == false) 
                {
                    log_print(_log_file, "        UNKNOWN\n");
                    is_print_head = true;
                }
                progress_print(region, max_region_name, is_has_record);
            }
        }
        if (is_print_head) {
            log_print(_log_file, " \n");
        }
        return;
    }

    if (mem_type == MEMORY_TYPE_RAM) {
        strncpy_s(str, sizeof(str), "        RAM", strlen("        RAM"));
    }
    else if (mem_type == MEMORY_TYPE_FLASH) {
        strncpy_s(str, sizeof(str), "        FLASH", strlen("        FLASH"));
    }

    if (is_offchip == false) {
        strncat_s(str, sizeof(str), " (on-chip)\n", strlen(" (on-chip)\n"));
    } else {
        strncat_s(str, sizeof(str), " (off-chip)\n", strlen(" (off-chip)\n"));
    }
    
    for (struct exec_region *region = e_region;
         region != NULL;
         region = region->next)
    {
        if (region->is_printed  == false
        &&  region->is_offchip  == is_offchip
        &&  region->memory_type == mem_type)
        {
            if (is_print_head == false)
            {
                log_print(_log_file, str);
                is_print_head = true;
            }
            progress_print(region, max_region_name, is_has_record);
            region->is_printed = true;
        }
    }

    if (is_print_head) {
        log_print(_log_file, " \n");
    }
}


/**
 * @brief  模式二打印内存占用情况
 * @note   
 * @param  e_region:        execution region
 * @param  max_region_name: 最大的 execution region 名称长度
 * @param  is_has_record:   是否有记录文件
 * @retval None
 */
void memory_mode2_print(struct exec_region *e_region,
                        size_t max_region_name, 
                        bool is_has_record)
{
    for (struct exec_region *region_temp = e_region;
         region_temp != NULL;
         region_temp = region_temp->next)
    {
        if (region_temp->is_printed == false)
        {
            progress_print(region_temp, max_region_name, is_has_record);
            region_temp->is_printed = true;
        }
    }
    log_print(_log_file, " \n");
}


/**
 * @brief  内存占用进度条化打印
 * @note   
 * @param  region:          execution region
 * @param  max_region_name: 最大的 execution region 名称长度
 * @param  is_has_record:   是否有记录文件
 * @retval None
 */
void progress_print(struct exec_region *region,
                    size_t max_region_name, 
                    bool is_has_record)
{
    double size = 0;
    double used_size = 0;
    uint32_t interge = 0;
    char size_str[MAX_PRJ_NAME_SIZE] = {0};
    char used_size_str[MAX_PRJ_NAME_SIZE] = {0};

    if (region->used_size < 1024)
    {
        used_size = region->used_size;
        snprintf(used_size_str, sizeof(used_size_str), "%8d", (uint32_t)used_size);
    }
    else if (region->used_size < (1024 * 1024))
    {
        used_size = (double)region->used_size / 1024;
        used_size = floor(used_size * 10) / 10;     /* 向下取整一位，防止被四舍五入 */
        snprintf(used_size_str, sizeof(used_size_str), "%5.1f KB", used_size);
    }
    else
    {
        used_size = (double)region->used_size / (1024 * 1024);
        used_size = floor(used_size * 10) / 10;
        snprintf(used_size_str, sizeof(used_size_str), "%5.1f MB", used_size);
    }

    if (region->size < 1024)
    {
        size = region->size;
        snprintf(size_str, sizeof(size_str), "%8d", (uint32_t)size);
    }
    else if (region->size < (1024 * 1024))
    {
        size = (double)region->size / 1024;
        size = floor(size * 10) / 10;
        snprintf(size_str, sizeof(size_str), "%5.1f KB", size);
    }
    else
    {
        size = (double)region->size / (1024 * 1024);
        size = floor(size * 10) / 10;
        snprintf(size_str, sizeof(size_str), "%5.1f MB", size);
    }

    double percent = (double)region->used_size * 100 / region->size;
    if (percent > 100) {
        percent = 100;
    }

    size_t used            = 0;
    char progress[256]     = {0};
    uint8_t zi_symbol[2]   = {0};
    uint8_t used_symbol[2] = {0};
    uint8_t symbol_size    = 0;

    symbol_size    = 1;
    zi_symbol[0]   = ZI_SYMBOL_0;
    used_symbol[0] = USED_SYMBOL_0;

    if (_progress_style == PROGRESS_STYLE_0)
    {
        if (_encoding_type == ENCODING_TYPE_GBK)
        {
            symbol_size    = 2;
            zi_symbol[0]   = ZI_SYMBOL_GBK_H;
            zi_symbol[1]   = ZI_SYMBOL_GBK_L;
            used_symbol[0] = USED_SYMBOL_GBK_H;
            used_symbol[1] = USED_SYMBOL_GBK_L;
        }
        else if (_encoding_type == ENCODING_TYPE_BIG5)
        {
            symbol_size    = 2;
            zi_symbol[0]   = ZI_SYMBOL_BIG5_H;
            zi_symbol[1]   = ZI_SYMBOL_BIG5_L;
            used_symbol[0] = USED_SYMBOL_BIG5_H;
            used_symbol[1] = USED_SYMBOL_BIG5_L;
        }
    }
    else if (_progress_style == PROGRESS_STYLE_2)
    {
        symbol_size    = 1;
        zi_symbol[0]   = ZI_SYMBOL_1;
        used_symbol[0] = USED_SYMBOL_1;
    }

    /* 先填充实际占用部分 */
    for (; used < ((uint32_t)percent / 2); used++)
    {
        memcpy(&progress[symbol_size * used], used_symbol, symbol_size);
    }
    /* 小于显示比例，避免是空的 */
    if (used == 0 && region->used_size != 0)
    {
        memcpy(&progress[0], used_symbol, symbol_size);
        used = 1;
    }
    /* 将占用部分的 ZI 部分替换 */
    for (struct region_block *block = region->zi_block;
         block != NULL;
         block = block->next)
    {
        size_t zi_start = ((double)block->start_addr - region->base_addr) * 100 / region->size / 2;
        size_t zi_end   = ((double)block->start_addr + block->size - region->base_addr) * 100 / region->size / 2;

        if (zi_start == 0 && block->start_addr > region->base_addr) {
            zi_start = 1;
        }
        log_save(_log_file, "                [zi start] %d   [zi end] %d\n", zi_start, zi_end);

        for (; zi_start < zi_end && zi_start < used; zi_start++) {
            memcpy(&progress[symbol_size * zi_start], zi_symbol, symbol_size);
        }

        if ((block->start_addr + block->size) >= (region->base_addr + region->size)) {
            break;
        }
    }
    /* 剩下未使用部分 */
    for (size_t unused = 0; unused < (50 - used); unused++){
        strncat_s(progress, sizeof(progress), UNUSE_SYMBOL, strlen(UNUSE_SYMBOL));
    }

    size_t space_len = max_region_name - strnlen_s(region->name, max_region_name) + 1;
    snprintf(_line_text, sizeof(_line_text),
             "                %s%*s [0x%08X]|%s| ( %s / %s ) %5.1f%%  ",
             region->name, space_len, " ", region->base_addr, progress, used_size_str, size_str, percent);

    if (is_has_record)
    {
        if (region->old_exec_region == NULL) {
            strncat_s(_line_text, sizeof(_line_text), "[NEW]", 5);
        }
        else
        {
            char sign;
            uint32_t data_increm = 0;
            char str_increm[MAX_PRJ_NAME_SIZE] = {0};

            if (region->used_size < region->old_exec_region->used_size)
            {
                sign = '-';
                data_increm = region->old_exec_region->used_size - region->used_size;
            }
            else
            {
                sign = '+';
                data_increm = region->used_size - region->old_exec_region->used_size;
            }

            if (data_increm)
            {
                snprintf(str_increm, sizeof(str_increm), "[%c%d]", sign, data_increm);
                strncat_s(_line_text, sizeof(_line_text), str_increm, strnlen_s(str_increm, sizeof(str_increm)));
            }
        }
    }
    log_print(_log_file, "%s\n", _line_text);
}


/**
 * @brief  打印栈使用情况
 * @note   
 * @param  file_path: htm 文件路径
 * @retval None
 */
void stack_print_process(const char *file_path)
{
    FILE *p_file = fopen(file_path, "r");
    if (p_file == NULL) {
        return;
    }

    char *str_p1 = NULL;
    char *str_p2 = NULL;
    while (fgets(_line_text, sizeof(_line_text), p_file))
    {
        str_p1 = strstr(_line_text, STR_MAX_STACK_USAGE);
        if (str_p1)
        {
            str_p2  = strrchr(_line_text, ')');
            str_p2 += 1;
            *str_p2 = '\0';
            log_print(_log_file, "%s\n \n", str_p1);
            break;
        }
    }
    fclose(p_file);
    return;
}


/**
 * @brief  按扩展名搜索文件
 * @note   本函数不会递归搜索
 * @param  dir:             要搜索的目录
 * @param  dir_len:         要搜索的目录长度
 * @param  extension[]:     扩展名，支持多个
 * @param  extension_qty:   扩展名数量
 * @param  list:            [out] 保存搜索到的文件路径
 * @retval None
 */
void search_files_by_extension(const char *dir, 
                               size_t dir_len,
                               const char *extension[], 
                               size_t extension_qty, 
                               struct prj_path_list *list)
{
    HANDLE h_find;
    WIN32_FIND_DATA find_data;

    /* 加上 '*' 以搜索所有文件和文件夹 */
    char *path = (char *)malloc(dir_len + 3);
    snprintf(path, dir_len + 3, "%s\\*", dir);

    /* 开始搜索 */
    h_find = FindFirstFile(path, &find_data);
    if (h_find == INVALID_HANDLE_VALUE) 
    {
        free(path);
        return;
    }

    do {
        /* 如果找到的是文件，判断其后缀是否为 keil 工程 */
        if ((find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
        {
            char *str = strrchr(find_data.cFileName, '.');
            if (str && is_same_string(str, extension, extension_qty))
            {
                size_t len = dir_len + strnlen_s(find_data.cFileName, MAX_PATH) + 2;
                char *file_path = malloc(len);
                snprintf(file_path, len, "%s\\%s", dir, find_data.cFileName);
                prj_path_list_add(list, file_path);
            }
        }
    } while (FindNextFile(h_find, &find_data));

    FindClose(h_find);
    free(path);
}


/**
 * @brief  log 记录
 * @note   
 * @param  p_log:    log 文件
 * @param  is_print: 是否打印
 * @param  fmt:      格式化字符串
 * @param  ...:      不定长参数 
 * @retval None
 */
void log_write(FILE *p_log, 
               bool is_print, 
               const char *fmt, 
               ...)
{
    va_list args;
    uint16_t len;
    static char buff[1024];
    
    va_start(args, fmt);

    memset(buff, 0, sizeof(buff));
    len = vsnprintf(buff, sizeof(buff) - 1, fmt, args);
    if (len > sizeof(buff) - 1) {
        len = sizeof(buff) - 1;
    }
    
    if (p_log && _is_save_log) {
        fputs(buff, p_log);
    }

    if (is_print) {
        printf("%s", buff);
    }
    
    va_end(args);
}


/**
 * @brief  拼接路径
 * @note   
 * @param  out_path:        [out] 拼接后输出的路径
 * @param  out_path_size:   输出的路径的大小
 * @param  absolute_path:   输入的绝对路径
 * @param  relative_path:   输入的相对路径
 * @retval 0: 正常 | -x: 错误
 */
int combine_path(char *out_path, 
                 size_t out_path_size,
                 const char *absolute_path, 
                 const char *relative_path)
{
    /* 1. 将绝对路径 absolute_path 的文件名和扩展名去除 */
    strncpy_s(out_path, out_path_size, absolute_path, strnlen_s(absolute_path, MAX_PATH));

    char *last_slash = strrchr(out_path, '\\');
    if (last_slash == NULL) {
        last_slash = strrchr(out_path, '/');
    }
    if (last_slash != NULL)
    {
        /* 说明不是是盘符根目录 */
        if (*(last_slash - 1) != ':') {
            *last_slash = '\0';
        }
    }
    else {
        return -1;
    }

    /* 2. 读取绝对路径的目录层级 并 记录每一层级的相对偏移值 */
    size_t hierarchy_count = 0;
    size_t dir_hierarchy[MAX_DIR_HIERARCHY];

    /* 逐字符遍历路径 */
    for (size_t i = 0; i < strnlen_s(out_path, out_path_size); i++)
    {
        if (out_path[i] == '\\' || out_path[i] == '/')
        {
            dir_hierarchy[hierarchy_count++] = i;

            if (hierarchy_count >= MAX_DIR_HIERARCHY) {
                break;
            }
        }
    }

    /* 3. 读取相对路径 relative_path 的向上层级数 */
    size_t dir_up_count = 0;
    size_t valid_path_offset = 0;

    for (size_t i = 0; i < strnlen_s(relative_path, MAX_PATH); )
    {
        if (relative_path[i]   == '.' 
        &&  relative_path[i+1] == '.' 
        &&  (relative_path[i+2] == '\\' || relative_path[i+2] == '/'))
        {
            i += 3;
            dir_up_count++;
            valid_path_offset += 3;
        }
        else if (relative_path[i]   == '.' 
        &&       (relative_path[i+1] == '\\' || relative_path[i+1] == '/')) 
        {
            valid_path_offset = 2;
            break;
        }
        else {
            break;
        }
    }

    /* 4. 根据 3 获得的级数，缩减绝对路径的目录层级 */
    if (dir_up_count > 0)
    {
        if ((hierarchy_count - dir_up_count) > 0)
        {
            hierarchy_count -= (dir_up_count - 1);
            size_t offset = dir_hierarchy[hierarchy_count - 1];
            out_path[offset] = '\0';
        }
        else {
            return -2;
        }
    }

    /* 5. 根据 2 记录的偏移值和 3 获得的级数，将 absolute_path 和 relative_path 拼接 */
    strncat_s(out_path, out_path_size, "\\", 1);
    strncat_s(out_path, out_path_size, &relative_path[valid_path_offset], strnlen_s(&relative_path[valid_path_offset], MAX_PATH));

    for (size_t i = 0; i < strnlen_s(out_path, out_path_size); i++)
    {
        if (out_path[i] == '/') {
            out_path[i] = '\\';
        }
    }

    return 0;
}


/**
 * @brief  创建新的文件信息并添加进链表
 * @note   
 * @param  path_head:   文件路径链表头
 * @param  name:        文件名
 * @param  path:        文件所在路径
 * @param  file_type:   文件类型
 * @retval true: 成功 | false: 失败
 */
bool file_path_add(struct file_path_list **path_head,
                   const char *name,
                   const char *path,
                   OBJECT_FILE_TYPE file_type)
{
    bool is_rename = false;
    char str[MAX_PRJ_NAME_SIZE] = {0};
    char old_name[MAX_PRJ_NAME_SIZE] = {0};
    struct file_path_list **path_list = path_head;

    memcpy_s(old_name, sizeof(old_name), name, strnlen_s(name, sizeof(old_name)));

    /* 可编译的文件和 lib 文件均会被编译为 .o 文件，此处提前进行文件扩展名的替换，便于后续的字符比对和查找 */
    if (file_type == OBJECT_FILE_TYPE_USER || file_type == OBJECT_FILE_TYPE_LIBRARY)
    {
        char *dot = strrchr(name, '.');
        if (dot) {
            *dot = '\0';
        }
        strncpy_s(str, sizeof(str), name, strnlen_s(name, sizeof(str)));
        strncat_s(str, sizeof(str), ".o", strlen(".o"));
    }
    else {
        strncpy_s(str, sizeof(str), name, strnlen_s(name, sizeof(str)));
    }

    if (*path_head)
    {
        struct file_path_list *list = *path_head;
        struct file_path_list *last_list = list;

        /* 文件名相同的可编译文件会被 keil 改名，此处提前处理，便于后续的字符比对和查找 */
        do {
            if (is_rename == false
            &&  (file_type == OBJECT_FILE_TYPE_USER || file_type == OBJECT_FILE_TYPE_LIBRARY)
            &&  strcmp(str, list->object_name) == 0) 
            {
                is_rename = true;
            }
            last_list = list;
            list = list->next;
        } while (list);

        path_list = &last_list->next;
    }

    *path_list = (struct file_path_list *)malloc(sizeof(struct file_path_list));

    (*path_list)->old_name        = strdup(old_name);
    (*path_list)->object_name     = strdup(str);
    (*path_list)->new_object_name = strdup(str);
    (*path_list)->path            = strdup(path);
    (*path_list)->file_type       = file_type;
    (*path_list)->is_rename       = is_rename;
    (*path_list)->next            = NULL;

    return true;
}


/**
 * @brief  释放文件信息链表占用的内存
 * @note   
 * @param  path_head: 链表头
 * @retval None
 */
void file_path_free(struct file_path_list **path_head)
{
    struct file_path_list *list = *path_head;
    while (list != NULL)
    {
        struct file_path_list *temp = list;
        list = list->next;
        free(temp->old_name);
        free(temp->object_name);
        free(temp->new_object_name);
        free(temp->path);
        free(temp);
    }
    *path_head = NULL;
}


/**
 * @brief  创建新的 memory 并添加进链表
 * @note   
 * @param  memory_head:     memory 链表头
 * @param  name:            memory 名称
 * @param  id:              memory ID
 * @param  base_addr:       memory 基地址
 * @param  size:            memory 大小，单位 byte
 * @param  mem_type:        memory 类型
 * @param  is_offchip:      是否为片外 memory
 * @param  is_from_pack:    信息是否来自 keil 的 pack
 * @retval true: 成功 | false: 失败
 */
bool memory_info_add(struct memory_info **memory_head,
                     const char  *name,
                     size_t      id,
                     uint32_t    base_addr,
                     uint32_t    size,
                     MEMORY_TYPE mem_type,
                     bool        is_offchip,
                     bool        is_from_pack)
{
    struct memory_info **memory = memory_head;

    if (*memory_head)
    {
        struct memory_info *memory_temp = *memory_head;

        while (memory_temp->next) {
            memory_temp = memory_temp->next;
        }
        memory = &memory_temp->next;
    }

    *memory = (struct memory_info *)malloc(sizeof(struct memory_info));
    if (name) {
        (*memory)->name = strdup(name);
    } else {
        (*memory)->name = NULL;
    }
    (*memory)->id           = id;
    (*memory)->base_addr    = base_addr;
    (*memory)->size         = size;
    (*memory)->type         = mem_type;
    (*memory)->is_offchip   = is_offchip;
    (*memory)->is_from_pack = is_from_pack;
    (*memory)->is_used      = false;
    (*memory)->next         = NULL;

    return true;
}


/**
 * @brief  释放 memory 链表占用的内存
 * @note   
 * @param  memory_head: memory 链表头
 * @retval None
 */
void memory_info_free(struct memory_info **memory_head)
{
    struct memory_info *memory = *memory_head;
    while (memory != NULL)
    {
        struct memory_info *temp = memory;
        memory = memory->next;
        if (temp->name) {
            free(temp->name);
        }
        free(temp);
    }
    *memory_head = NULL;
}


/**
 * @brief  创建新的 load region
 * @note   
 * @param  region_head: region 链表头
 * @param  name:        region 名称
 * @retval NULL | struct load_region *
 */
struct load_region * load_region_create(struct load_region **region_head, const char *name)
{
    struct load_region **region = region_head;

    if (*region_head)
    {
        struct load_region *region_temp = *region_head;

        while (region_temp->next) {
            region_temp = region_temp->next;
        }
        region = &region_temp->next;
    }

    *region = (struct load_region *)malloc(sizeof(struct load_region));

    (*region)->name = strdup(name);
    if ((*region)->name == NULL) {
        return NULL;
    }
    (*region)->exec_region = NULL;
    (*region)->next        = NULL;

    return (*region);
}


/**
 * @brief  创建新的 execution region 并添加进 load region 链表
 * @note   
 * @param  l_region:            load region 链表头
 * @param  name:                execution region 名
 * @param  load_region_name:    所属的 load region 名
 * @param  memory_id:           所在的内存 ID
 * @param  base_addr:           execution region 基地址
 * @param  size:                execution region 大小，单位 byte
 * @param  used_size:           execution region 已使用大小，单位 byte
 * @param  mem_type:            execution region 内存类型
 * @param  is_offchip:          是否为片外 memory
 * @retval NULL | struct exec_region *
 */
struct exec_region * load_region_add_exec_region(struct load_region **l_region, 
                                                 const char  *name,
                                                 const char  *load_region_name,
                                                 size_t      memory_id,
                                                 uint32_t    base_addr,
                                                 uint32_t    size,
                                                 uint32_t    used_size,
                                                 MEMORY_TYPE mem_type,
                                                 bool        is_offchip)
{
    if (*l_region == NULL) {
        return NULL;
    }

    struct exec_region **e_region = &((*l_region)->exec_region);

    if ((*l_region)->exec_region)
    {
        struct exec_region *region_temp = (*l_region)->exec_region;

        while (region_temp->next) {
            region_temp = region_temp->next;
        }

        e_region = &region_temp->next;
    }

    *e_region = (struct exec_region *)malloc(sizeof(struct exec_region));
    
    if (load_region_name) {
        (*e_region)->load_region_name = strdup(load_region_name);
    } else {
        (*e_region)->load_region_name = strdup(UNUSED_LOAD_REGION_NAME);
    }
    (*e_region)->name             = strdup(name);
    (*e_region)->memory_id        = memory_id;
    (*e_region)->base_addr        = base_addr;
    (*e_region)->size             = size;
    (*e_region)->used_size        = used_size;
    (*e_region)->memory_type      = mem_type;
    (*e_region)->is_offchip       = is_offchip;
    (*e_region)->is_printed       = false;
    (*e_region)->zi_block         = NULL;
    (*e_region)->old_exec_region  = NULL;
    (*e_region)->next             = NULL;

    return (*e_region);
}


/**
 * @brief  释放 load region 链表占用的内存
 * @note   
 * @param  region_head: 链表头
 * @retval None
 */
void load_region_free(struct load_region **region_head)
{
    struct load_region *l_region = *region_head;
    while (l_region != NULL)
    {
        struct load_region *l_region_temp = l_region;

        struct exec_region *e_region = l_region_temp->exec_region;
        while (e_region != NULL)
        {
            struct exec_region *e_region_temp = e_region;
            
            e_region = e_region->next;
            free(e_region_temp->name);
            free(e_region_temp->load_region_name);

            struct region_block *block = e_region_temp->zi_block;
            while (block != NULL)
            {
                struct region_block *block_temp = block;

                block = block->next;
                free(block_temp);
            }

            free(e_region_temp);
        }

        l_region = l_region->next;
        free(l_region_temp->name);
        free(l_region_temp);
    }
    *region_head = NULL;
}


/**
 * @brief  创建新的 object 文件信息并添加进链表
 * @note   
 * @param  object_head: 链表头
 * @param  name:        object 文件名
 * @param  code:        code 大小，单位 byte
 * @param  ro_data:     read-only data 大小，单位 byte
 * @param  rw_data:     read-write data 大小，单位 byte
 * @param  zi_data:     zero-initialize data 大小，单位 byte
 * @retval true: 成功 | false: 失败
 */
bool object_info_add(struct object_info **object_head,
                     const char *name,
                     uint32_t   code,
                     uint32_t   ro_data,
                     uint32_t   rw_data,
                     uint32_t   zi_data)
{
    struct object_info **object = object_head;

    if (*object_head)
    {
        struct object_info *object_temp = *object_head;

        while (object_temp->next) {
            object_temp = object_temp->next;
        }
        object = &object_temp->next;
    }

    *object = (struct object_info *)malloc(sizeof(struct object_info));
    (*object)->name = strdup(name);
    if ((*object)->name == NULL) {
        return false;
    }
    (*object)->code       = code;
    (*object)->ro_data    = ro_data;
    (*object)->rw_data    = rw_data;
    (*object)->zi_data    = zi_data;
    (*object)->path       = NULL;
    (*object)->old_object = NULL;
    (*object)->next       = NULL;

    return true;
}


/**
 * @brief  释放 object 文件信息占用的内存
 * @note   
 * @param  object_head: 链表头
 * @retval None
 */
void object_info_free(struct object_info **object_head)
{
    struct object_info *object = *object_head;
    while (object != NULL)
    {
        struct object_info *temp = object;
        object = object->next;
        free(temp->name);
        free(temp);
    }
    *object_head = NULL;
}


/**
 * @brief  初始化动态列表
 * @note   
 * @param  capacity: 列表容量
 * @retval NULL | struct prj_path_list *
 */
struct prj_path_list * prj_path_list_init(size_t capacity)
{
    struct prj_path_list *list = malloc(sizeof(struct prj_path_list));

    list->items    = malloc(capacity * sizeof(char *));
    list->capacity = capacity;
    list->size     = 0;

    return list;
}


/**
 * @brief  向动态列表添加元素
 * @note   
 * @param  list: 列表对象
 * @param  item: 要新增的项
 * @retval None
 */
void prj_path_list_add(struct prj_path_list *list, char *item)
{
    /* 如果数组已满，将其最大容量翻倍 */
    if (list->size == list->capacity)
    {
        list->capacity *= 2;
        list->items = realloc(list->items, list->capacity * sizeof(char *));
    }
    list->items[list->size++] = item;
}


/**
 * @brief  释放动态列表
 * @note   
 * @param  list: 列表对象
 * @retval None
 */
void prj_path_list_free(struct prj_path_list *list)
{
    for (size_t i = 0; i < list->size; i++) {
        free(list->items[i]);
    }
    free(list->items);
    free(list);
}


/**
 * @brief  某路径是否为 keil 工程
 * @note   
 * @param  path: 路径
 * @retval true: 是 | false: 否
 */
bool is_keil_project(const char *path)
{
    for (size_t i = 0; i < sizeof(_keil_prj_extension) / sizeof(_keil_prj_extension[0]); i++)
    {
        char *dot = strrchr(path, '.');
        if (dot == NULL) {
            return false;
        }

        if (strncmp(dot, _keil_prj_extension[i], strlen(_keil_prj_extension[i])) == 0) {
            return true;
        }
    }

    return false;
}


/**
 * @brief  字符串比对
 * @note   
 * @param  str1:     字符串 1
 * @param  str2[]:   字符串组 2
 * @param  str2_qty: 字符串组 2 的数量
 * @retval true: 一致 | false: 不一致
 */
bool is_same_string(const char *str1, 
                    const char *str2[], 
                    size_t str2_qty)
{
    for (size_t i = 0; i < str2_qty; i++)
    {
        if (strcmp(str1, str2[i]) == 0) {
            return true;
        }
    }

    return false;
}