C语言写exe脚本

文章目录

• win下面写exe
• ubuntu下写exe
• py写exe

---

目的：我现在有一个DBC文件，我要根据这个N01的DBC生成16个DBC，分别是N01~N16.这个DBC文件里面的N01都替换为N02 N03.. 对于扩展帧id，需要id每加1，扩展帧就加0x10000.因为第5位和第6位是硬件id

win下面写exe

1.安装vscode

2.安装mingw64和cmake(个人笔记有)

看版本号，下面就是mingw安装完成

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>

#define BUFFER_SIZE 4096
#define BASE_INCREMENT 0x10000  // 基础增量值

// 完善的字符串替换函数
char* replace_string_complete(const char* source, const char* old_str, const char* new_str) {
    if (!source || !old_str || !new_str) return NULL;
    
    // 计算原字符串中旧子串出现的次数
    int count = 0;
    const char* temp = source;
    while ((temp = strstr(temp, old_str)) != NULL) {
        count++;
        temp += strlen(old_str);
    }
    
    if (count == 0) {
        char* result = (char*)malloc(strlen(source) + 1);
        if (result) strcpy(result, source);
        return result;
    }
    
    // 计算新字符串的长度
    size_t old_len = strlen(old_str);
    size_t new_len = strlen(new_str);
    size_t new_size = strlen(source) + count * (new_len - old_len) + 1;
    
    char* result = (char*)malloc(new_size);
    if (!result) return NULL;
    
    // 执行替换
    const char* src_ptr = source;
    char* dst_ptr = result;
    
    while (*src_ptr) {
        if (strstr(src_ptr, old_str) == src_ptr) {
            strcpy(dst_ptr, new_str);
            src_ptr += old_len;
            dst_ptr += new_len;
        } else {
            *dst_ptr++ = *src_ptr++;
        }
    }
    *dst_ptr = '\0';
    
    return result;
}

// 替换 BO_ 和 VAL_ 后面的数字（加上指定倍数的增量）
int replace_big_numbers_with_multiplier(char* line, int multiplier) {
    if (!line || multiplier < 1) return 0;
    
    int modified = 0;
    
    // 只处理以 BO_ 或 VAL_ 开头的行
    if (strncmp(line, "BO_ ", 4) != 0 && strncmp(line, "VAL_ ", 5) != 0) {
        return 0;
    }
    
    // 确定类型
    int is_val = (line[0] == 'V');
    char* number_start = is_val ? line + 5 : line + 4;
    
    // 跳过空格
    while (*number_start == ' ') number_start++;
    
    // 找到数字开始位置
    char* num_start = number_start;
    while (*num_start && !(*num_start >= '0' && *num_start <= '9')) {
        num_start++;
    }
    
    if (!*num_start) return 0;
    
    // 找到数字结束位置
    char* num_end = num_start;
    while (*num_end >= '0' && *num_end <= '9') {
        num_end++;
    }
    
    int num_len = num_end - num_start;
    if (num_len < 1) return 0;
    
    // 提取数字
    char num_str[30];
    strncpy(num_str, num_start, num_len);
    num_str[num_len] = '\0';
    
    // 转换为数字
    unsigned long long original_num = strtoull(num_str, NULL, 10);
    
    // 计算总增量：0x10000 × (N - 1)
    unsigned long long total_increment = BASE_INCREMENT * multiplier;
    unsigned long long new_num = original_num + total_increment;
    
    // 生成新的数字字符串
    char new_num_str[30];
    sprintf(new_num_str, "%llu", new_num);
    
    // 计算长度差异
    int new_len = strlen(new_num_str);
    
    // 直接替换（DBC中的这些数字通常长度相同）
    if (new_len == num_len) {
        memcpy(num_start, new_num_str, new_len);
        modified = 1;
    }
    
    return modified;
}

// 从文件名中提取前缀（xxxx部分）
void extract_prefix(const char* filename, char* prefix) {
    // 查找第一个下划线
    const char* first_underscore = strchr(filename, '_');
    if (!first_underscore) {
        strcpy(prefix, filename);
        return;
    }
    
    // 复制前缀部分
    int len = first_underscore - filename;
    strncpy(prefix, filename, len);
    prefix[len] = '\0';
}

// 生成输出文件名
void generate_output_filename(const char* input_file, int file_number, char* output_file) {
    char prefix[256];
    extract_prefix(input_file, prefix);
    
    // 生成文件名：xxxx_N{file_number}_r.dbc
    sprintf(output_file, "%s_N%02d_r.dbc", prefix, file_number);
}

int main() {
    // 设置控制台
    system("chcp 936 > nul");
    system("title DBC批量生成工具 v4.0");
    system("color 0A");
    system("cls");
    
    printf("========================================\n");
    printf("        DBC批量生成工具 v4.0\n");
    printf("========================================\n");
    printf("功能：根据输入文件批量生成N个DBC文件\n");
    printf("规则：\n");
    printf("  1. N01 → N{file_number}\n");
    printf("  2. 数字增量：0x10000 × (file_number - 1)\n");
    printf("========================================\n\n");
    
    // 用户输入
    char input_file[256];
    int max_file_number;
    
    printf("请输入输入文件名（如 TIO3004_N01_r.dbc）：");
    scanf("%255s", input_file);
    
    do {
        printf("请输入要生成的最大文件号（2-99）：");
        scanf("%d", &max_file_number);
        
        if (max_file_number < 2 || max_file_number > 99) {
            printf(" 错误：请输入2到99之间的数字！\n");
        }
    } while (max_file_number < 2 || max_file_number > 99);
    
    printf("\n处理设置：\n");
    printf("  输入文件：%s\n", input_file);
    printf("  生成文件数：%d 个 (N02 到 N%02d)\n", max_file_number - 1, max_file_number);
    printf("  基础增量：0x10000 (十进制: %d)\n", BASE_INCREMENT);
    printf("\n正在处理...\n");
    
    // 检查输入文件是否存在
    FILE* test_fin = fopen(input_file, "r");
    if (!test_fin) {
        printf("错误：无法打开输入文件！\n");
        Sleep(5000);
        return 1;
    }
    fclose(test_fin);
    
    // 统计总信息
    int total_string_replacements = 0;
    int total_number_replacements = 0;
    int success_count = 0;
    
    // 为每个文件号生成文件
    for (int file_number = 2; file_number <= max_file_number; file_number++) {
        // 生成输出文件名
        char output_file[256];
        generate_output_filename(input_file, file_number, output_file);
        
        printf("\n--- 正在生成 %s ---\n", output_file);
        
        // 打开输入文件
        FILE* fin = fopen(input_file, "r");
        if (!fin) {
            printf("  错误：无法打开输入文件！\n");
            continue;
        }
        
        // 创建输出文件
        FILE* fout = fopen(output_file, "w");
        if (!fout) {
            printf("  错误：无法创建输出文件！\n");
            fclose(fin);
            continue;
        }
        
        // 准备要查找和替换的字符串
        char old_string[10], new_string[10];
        sprintf(old_string, "N01");
        sprintf(new_string, "N%02d", file_number);
        
        // 计算倍数：file_number - 1
        int multiplier = file_number - 1;
        
        // 处理文件
        char line[BUFFER_SIZE];
        int line_count = 0;
        int string_replacements = 0;
        int number_replacements = 0;
        
        while (fgets(line, BUFFER_SIZE, fin)) {
            line_count++;
            
            // 替换字符串：N01 → N{file_number}
            char* temp_line = replace_string_complete(line, old_string, new_string);
            if (temp_line) {
                // 统计字符串替换
                if (strcmp(line, temp_line) != 0) {
                    string_replacements++;
                }
                
                // 替换数字：加上 0x10000 × (file_number - 1)
                int number_changed = replace_big_numbers_with_multiplier(temp_line, multiplier);
                if (number_changed) {
                    number_replacements++;
                }
                
                // 写入输出文件
                fputs(temp_line, fout);
                free(temp_line);
            } else {
                fputs(line, fout);
            }
        }
        
        // 关闭文件
        fclose(fin);
        fclose(fout);
        
        // 显示单个文件结果
        printf("  处理完成：\n");
        printf("    行数：%d\n", line_count);
        printf("    字符串替换：%s → %s : %d 处\n", 
               old_string, new_string, string_replacements);
        printf("    数字增量：0x10000 × %d : %d 处\n", 
               multiplier, number_replacements);
        
        // 累计总统计
        total_string_replacements += string_replacements;
        total_number_replacements += number_replacements;
        success_count++;
    }
    
    // 显示总体结果
    printf("\n\n========================================\n");
    printf(" 批量生成完成！\n");
    printf("========================================\n");
    printf("总体统计：\n");
    printf("  输入文件：%s\n", input_file);
    printf("  成功生成：%d 个文件\n", success_count);
    printf("  生成范围：N02 到 N%02d\n", max_file_number);
    printf("  总字符串替换：%d 处\n", total_string_replacements);
    printf("  总数字修改：%d 处\n", total_number_replacements);
    
    // 列出生成的文件
    printf("\n生成的文件列表：\n");
    for (int i = 2; i <= max_file_number; i++) {
        char filename[256];
        generate_output_filename(input_file, i, filename);
        
        // 检查文件是否存在
        FILE* check = fopen(filename, "r");
        if (check) {
            fclose(check);
            printf("  %s\n", filename);
        } else {
            printf("  %s (生成失败)\n", filename);
        }
    }
    
    // 显示处理规则示例
    printf("\n处理规则示例（以 N16 为例）：\n");
    printf("  1. 所有 N01 → N16\n");
    printf("  2. 数字增量：0x10000 × (16 - 1) = 0x10000 × 15 = 0xF0000\n");
    printf("     2550146862 → 2550146862 + 0xF0000 = 2566646862\n");
    
    while(1);
    return 0;
}

然后生成exe文件 gcc DBC_Builder.c -o dbc_processor.exe。执行即可

ubuntu下写exe

ubuntu虚拟机下写exe是不合适的，因为linux下不支持exe文件，还需要把exe放到共享文件夹(和主机共享)，然后在win下面执行。

同样也要按照mingw

py写exe

Python一行搞定

content = content.replace("N01", "N16")

C需要几十行代码

// 需要处理内存分配、字符串长度、查找替换...

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
DBC批量生成工具 - Python版
功能：根据输入文件批量生成多个DBC文件
"""

import os
import re

def generate_dbc_files():
    print("=" * 50)
    print("      DBC批量生成工具 - Python版")
    print("=" * 50)
    
    # 输入参数
    input_file = input("请输入输入文件名（如 TIO3004_N01_r.dbc）：").strip()
    
    while True:
        try:
            max_num = int(input("请输入要生成的最大文件号（2-99）："))
            if 2 <= max_num <= 99:
                break
            print("请输入2到99之间的数字！")
        except ValueError:
            print("请输入有效的数字！")
    
    print(f"\n处理设置：")
    print(f"  输入文件：{input_file}")
    print(f"  生成文件数：{max_num-1} 个 (N02 到 N{max_num:02d})")
    print(f"  基础增量：0x10000 (十进制: 65536)")
    print("\n正在处理...")
    
    # 检查输入文件
    if not os.path.exists(input_file):
        print(f"❌ 错误：文件 {input_file} 不存在！")
        input("按回车键退出...")
        return
    
    # 读取输入文件
    with open(input_file, 'r', encoding='utf-8') as f:
        content = f.read()
    
    # 提取文件名前缀
    base_name = os.path.splitext(input_file)[0]
    if '_N01_r' in base_name:
        prefix = base_name.replace('_N01_r', '')
    else:
        prefix = base_name
    
    success_count = 0
    
    # 为每个文件号生成文件
    for file_num in range(2, max_num + 1):
        # 生成输出文件名
        output_file = f"{prefix}_N{file_num:02d}_r.dbc"
        
        print(f"\n--- 正在生成 {output_file} ---")
        
        # 计算倍数
        multiplier = file_num - 1
        
        # 处理内容
        new_content = content
        
        # 1. 替换 N01 为 N{file_num}
        old_str = "N01"
        new_str = f"N{file_num:02d}"
        new_content = new_content.replace(old_str, new_str)
        
        # 2. 替换 BO_ 和 VAL_ 后面的数字
        lines = new_content.split('\n')
        processed_lines = []
        
        for line in lines:
            # 处理 BO_ 和 VAL_ 开头的行
            if line.startswith('BO_ ') or line.startswith('VAL_ '):
                # 使用正则表达式匹配第一个数字
                match = re.search(r'^(\w+_ )(\d+)(.*)', line)
                if match:
                    prefix_part = match.group(1)
                    number = int(match.group(2))
                    rest = match.group(3)
                    
                    # 计算新数字
                    increment = 0x10000 * multiplier
                    new_number = number + increment
                    
                    # 重新构建行
                    new_line = f"{prefix_part}{new_number}{rest}"
                    processed_lines.append(new_line)
                else:
                    processed_lines.append(line)
            else:
                processed_lines.append(line)
        
        new_content = '\n'.join(processed_lines)
        
        # 写入输出文件
        with open(output_file, 'w', encoding='utf-8') as f:
            f.write(new_content)
        
        print(f"  ✅ 生成成功")
        success_count += 1
    
    # 显示结果
    print(f"\n" + "=" * 50)
    print(f"✅ 批量生成完成！")
    print(f"=" * 50)
    print(f"成功生成：{success_count} 个文件")
    print(f"生成范围：N02 到 N{max_num:02d}")
    
    # 显示示例
    print(f"\n处理规则示例（以 N{max_num} 为例）：")
    print(f"  1. 所有 N01 → N{max_num:02d}")
    print(f"  2. 数字增量：0x10000 × ({max_num} - 1) = 0x{0x10000 * (max_num-1):X}")
    
    input("\n按回车键退出...")

if __name__ == "__main__":
    generate_dbc_files()