makefile 转 cmake STM32工程

makefile 转 cmake STM32工程

STM32开发由MDK转到 vscode好久了。每次新建工程，stm32cubemx生成代码都要手动把makefile转到cmake，好烦，特别一下小的频繁更改。
故，一劳永逸，搞了个python脚本，一键转

测试环境

• vscode 1.63.2
• cmake 3.20
• arm gcc 10.2

1. STM32CUBEMX生成代码时选择makefile，不要选keil
2. 运行脚本
3. 生成CMakeLists.txt

代码

目前只测试了少量几个工程，都是M0

import os
import re

cmake_head = [
    "set(CMAKE_SYSTEM_NAME  Generic)\n",
    "set(CMAKE_SYSTEM_PROCESSOR cortex-m0+)\n",
    "include(target.cmake)\n",
    "cmake_minimum_required(VERSION 3.1.6)\n",
]

cmake_hex = [
    "set(BIN_TARGET ${PROJECT_NAME}.bin)\n",
    "set(HEX_TARGET ${PROJECT_NAME}.hex)\n",
    "set(LSS_TARGET ${PROJECT_NAME}.lss)\n",
    "\n",
    "# create binary & hex files and show size of resulting firmware image\n",
    "add_custom_command(TARGET ${PROJECT_NAME}.elf POST_BUILD\n",
    "        COMMAND ${CMAKE_OBJCOPY} -Oihex $<TARGET_FILE:${PROJECT_NAME}.elf> ${HEX_TARGET}\n",
    "        COMMAND ${CMAKE_OBJCOPY} -Obinary $<TARGET_FILE:${PROJECT_NAME}.elf> ${BIN_TARGET}\n",
    "        COMMAND ${ARM_OBJDUMP_EXECUTABLE} -S $<TARGET_FILE:${PROJECT_NAME}.elf> > ${LSS_TARGET}\n",
    "        COMMAND ${ARM_SIZE_EXECUTABLE} -B ${PROJECT_NAME}.elf\n",
    "        COMMENT \"Generating ${HEX_TARGET}, ${BIN_TARGET}\")\n",
]
target_gcc_head = [
    "######设置编译器###########\n",
    "set(CMAKE_C_COMPILER arm-none-eabi-gcc)\n",
    "set(CMAKE_CXX_COMPILER arm-none-eabi-g++)\n",
    "set(CMAKE_ASM_COMPILER arm-none-eabi-gcc)\n",
    "set(CMAKE_OBJCOPY arm-none-eabi-objcopy)\n",
    "set(CMAKE_OBJDUMP arm-none-eabi-objdump)\n",
    "set(CMAKE_C_COMPILER_WORKS TRUE)\n",
    "set(CMAKE_CXX_COMPILER_WORKS TRUE)\n",
    "set(CMAKE_ASM_COMPILER_WORKS TRUE)\n",
    "set(CMAKE_TRY_COMPILE_TARGET_TYPE \"STATIC_LIBRARY\")\n\n\n",
    "find_program(ARM_SIZE_EXECUTABLE arm-none-eabi-size)\n",
    "find_program(ARM_GDB_EXECUTABLE arm-none-eabi-gdb)\n",
    "find_program(ARM_OBJCOPY_EXECUTABLE arm-none-eabi-objcopy)\n",
    "find_program(ARM_OBJDUMP_EXECUTABLE arm-none-eabi-objdump)\n\n\n\n",
    "######优化等级###########\n",
    "if(CMAKE_BUILD_TYPE MATCHES Debug)\n",
    "set(OPT \"-g -gdwarf-3 -O0\")\n",
    "elseif(CMAKE_BUILD_TYPE MATCHES Release)\n",
    "set(OPT \"-O3\")\n",
    "elseif(CMAKE_BUILD_TYPE MATCHES MinSizeRel)\n",
    "set(OPT \"-Os\")\n",
    "elseif(CMAKE_BUILD_TYPE MATCHES RelWithDebInfo)\n",
    "set(OPT \"-gdwarf-3 -Ofast\")\n",
    "endif()\n",
]


def write_var(f, var, v):
    f.write("set(%s %s)\n" % (var, v))


def open_makefile():
    if os.path.isfile("Makefile") == True:
        print("find makefile")
        makefile = open("Makefile").read()

        project_name = re.findall(r'TARGET = [\d\w]*', makefile)[0]
        project_name = re.findall(r'[\d\w]+', project_name)[1]
        print(project_name)

        LDSCRIPT = re.findall(r'[\S]*\.ld', makefile)[0]
        print(LDSCRIPT)

        c_source = re.findall(
            r'# C sources[\W\S\D\d\w\s]*# ASM sources', makefile)[0]
        c_source = re.findall(r'[\S]*\.c', c_source)
        print(c_source)

        asm_source = re.findall(
            r'# ASM sources[\W\S\D\d\w\s]*# binaries', makefile)[0]
        asm_source = re.findall(r'[\S]*\.s', asm_source)
        print(asm_source)

        c_include = []
        temp = re.findall(r'-I[\S]*', makefile)
        for c in temp:
            c_include.append(c[2:])

        c_def = re.findall(r'-D[\S]*', makefile)

        cpu = re.findall(r'-mcpu[\S]*', makefile)
        fpu = re.findall(r'-mfpu[\S]*', makefile)
        flaot_abi = re.findall(r'-mfloat-abi[\S]*', makefile)

        c_flags = re.findall(
            r'CFLAGS = .*', makefile)[0][len("CFLAGS = "):].replace("(", "{").replace(")", "}")

        asm_flags = re.findall(
            r'ASFLAGS = .*', makefile)[0][len("ASFLAGS = "):].replace("(", "{").replace(")", "}")

        link_flags = re.findall(
            r'LDFLAGS = .*', makefile)[0][len("LDFLAGS = "):].replace("(", "{").replace(")", "}")

        libs = re.findall(r'LIBS = .*', makefile)[0][len("LIBS = "):]
        print(libs)
###################target.cmake####################################
        target_file = open("target.cmake", "w", encoding='utf-8')
        target_file.writelines(target_gcc_head)

        target_file.writelines("\n\n###宏定义##########\n")
        for c in c_def:
            target_file.write("add_definitions(%s)\n" % (c))

        target_file.writelines("\n\n###编译器选项##########\n")
        write_var(target_file, "LDSCRIPT",
                  "${CMAKE_CURRENT_SOURCE_DIR}/"+LDSCRIPT)
        write_var(target_file, "LIBS", "\""+libs+"\"")
        if len(cpu) > 0:
            write_var(target_file, "CPU", cpu[0])
        if len(fpu) > 0:
            write_var(target_file, "FPU", fpu[0])
        if len(flaot_abi) > 0:
            write_var(target_file, "FLOAT_ABI", flaot_abi[0])

        write_var(target_file, "MCU", "\"${CPU} -mthumb ${FPU} ${FLOAT_ABI}\"")

        target_file.write(
            "set(CMAKE_C_FLAGS \" % s\" CACHE INTERNAL \"C compiler flags\")\n" % (c_flags))
        target_file.write(
            "set(CMAKE_CXX_FLAGS \" % s\" CACHE INTERNAL \"Cxx compiler flags\")\n" % (c_flags))
        target_file.write(
            "set(CMAKE_ASM_FLAGS \" % s\" CACHE INTERNAL \"ASM compiler flags\")\n" % (asm_flags))

        target_file.write(
            "set(CMAKE_EXE_LINKER_FLAGS \" % s\" CACHE INTERNAL \"Exe linker flags\")\n" % (link_flags))

        target_file.close()
# ----------------CMakeLists.txt------------------------------
        cmake_file = open("CMakeLists.txt", "w", encoding='utf-8')
        cmake_file.writelines(cmake_head)

        cmake_file.write("project(%s C CXX ASM)\n\n" % project_name)

        cmake_file.write("set(_SRC\n")
        for src in c_source:
            cmake_file.write("%s\n" % src)
        for src in asm_source:
            cmake_file.write("%s\n" % src)
        cmake_file.write(")\n")

        cmake_file.write("include_directories(\n")
        for c_in in c_include:
            cmake_file.write("%s\n" % c_in)
        cmake_file.write(")\n")

        cmake_file.write(
            "add_executable(${PROJECT_NAME}.elf  ${_SRC})\n\n")
        cmake_file.write(
            "include(app.cmake)\n\n")

        cmake_file.writelines(cmake_hex)
        cmake_file.close()
# ----------------app.cmake------------------------------
        if os.path.isfile("app.cmake") == False:
            app_cmake = open("app.cmake", "w", encoding='utf-8')
            app_cmake.write("#app file \n\n")
            app_cmake.close()


if __name__ == '__main__':
    open_makefile()