255 lines
8.6 KiB
Python
Executable File
255 lines
8.6 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*
|
|
"""
|
|
@brief CMake configuration helper
|
|
@details
|
|
This script was written to have a portable way to perform the CMake configuration with various parameters on
|
|
different OSes. It was first written for the FSFW Example, but could be adapted to be more generic
|
|
in the future.
|
|
|
|
Run cmake_build_config.py --help to get more information.
|
|
"""
|
|
import os
|
|
import platform
|
|
import sys
|
|
import argparse
|
|
import shutil
|
|
|
|
|
|
def main():
|
|
print("-- Python CMake build configurator utility --")
|
|
|
|
print("Parsing command line arguments..")
|
|
parser = argparse.ArgumentParser(description="Processing arguments for CMake build configuration.")
|
|
parser.add_argument(
|
|
"-o", "--osal", type=str, choices=["freertos", "linux", "rtems", "host"],
|
|
help="FSFW OSAL. Valid arguments: host, linux, rtems, freertos"
|
|
)
|
|
parser.add_argument(
|
|
"-b", "--buildtype", type=str, choices=["debug", "release", "size", "reldeb"],
|
|
help="CMake build type. Valid arguments: debug, release, size, reldeb (Release with Debug Information)",
|
|
default="debug"
|
|
)
|
|
parser.add_argument("-l", "--builddir", type=str, help="Specify build directory.")
|
|
parser.add_argument(
|
|
"-g", "--generator", type=str, help="CMake Generator", choices=["make", "ninja"]
|
|
)
|
|
parser.add_argument(
|
|
"-t", "--target-bsp", type=str, help="Target BSP, combination of architecture and machine"
|
|
)
|
|
parser.add_argument(
|
|
"-d", "--defines",
|
|
help="Additional custom defines passed to CMake (supply without -D prefix!)",
|
|
nargs="*", type=str
|
|
)
|
|
|
|
args = parser.parse_args()
|
|
|
|
print("Determining source location..")
|
|
source_location = determine_source_location()
|
|
print(f"Determined source location: {source_location}")
|
|
|
|
print("Building cmake configuration command..")
|
|
|
|
if args.generator is None:
|
|
generator = determine_build_generator()
|
|
generator_cmake_arg = f"-G \"{generator}\""
|
|
else:
|
|
if args.generator == "make":
|
|
if os.name == 'nt':
|
|
generator_cmake_arg = '-G "MinGW Makefiles"'
|
|
else:
|
|
generator_cmake_arg = '-G "Unix Makefiles"'
|
|
elif args.generator == 'ninja':
|
|
generator_cmake_arg = '-G Ninja'
|
|
else:
|
|
generator_cmake_arg = args.generator
|
|
|
|
if args.osal is None:
|
|
print("No FSFW OSAL specified.")
|
|
cmake_fsfw_osal = determine_fsfw_osal()
|
|
else:
|
|
cmake_fsfw_osal = args.osal
|
|
|
|
cmake_build_type = determine_build_type(args.buildtype)
|
|
|
|
cmake_target_cfg_cmd = ''
|
|
|
|
define_string = ""
|
|
if args.defines is not None:
|
|
define_list = args.defines[0].split()
|
|
for define in define_list:
|
|
define_string += f"-D{define} "
|
|
|
|
if args.builddir is None:
|
|
cmake_build_folder = determine_build_folder(cmake_build_type)
|
|
else:
|
|
cmake_build_folder = args.builddir
|
|
|
|
build_path = source_location + os.path.sep + cmake_build_folder
|
|
if os.path.isdir(build_path):
|
|
remove_old_dir = input(f"{cmake_build_folder} folder already exists. "
|
|
f"Remove old directory? [y/n]: ")
|
|
if str(remove_old_dir).lower() in ["yes", "y", 1]:
|
|
remove_old_dir = True
|
|
else:
|
|
cmake_build_folder = determine_new_folder()
|
|
build_path = source_location + os.path.sep + cmake_build_folder
|
|
remove_old_dir = False
|
|
if remove_old_dir:
|
|
try:
|
|
shutil.rmtree(build_path)
|
|
except PermissionError as error:
|
|
print(error)
|
|
print("File might still be opened!")
|
|
sys.exit(0)
|
|
os.chdir(source_location)
|
|
os.mkdir(cmake_build_folder)
|
|
print(f"Navigating into build directory: {build_path}")
|
|
os.chdir(cmake_build_folder)
|
|
|
|
cmake_command = f"cmake {generator_cmake_arg} -DFSFW_OSAL=\"{cmake_fsfw_osal}\" " \
|
|
f"-DCMAKE_BUILD_TYPE=\"{cmake_build_type}\" {cmake_target_cfg_cmd} " \
|
|
f"{define_string} {source_location}"
|
|
# Remove redundant spaces
|
|
cmake_command = ' '.join(cmake_command.split())
|
|
print("Running CMake command (without +): ")
|
|
print(f"+ {cmake_command}")
|
|
os.system(cmake_command)
|
|
print("-- CMake configuration done. --")
|
|
|
|
|
|
def determine_build_generator() -> str:
|
|
print("No generator specified. ")
|
|
print("Please select from the following list of build types or type "
|
|
"in desired system directly [h for help]: ")
|
|
while True:
|
|
user_input = input("Enter your selection: ")
|
|
if user_input == "h":
|
|
os.system("cmake --help")
|
|
else:
|
|
build_generator = user_input
|
|
confirmation = input(f"Confirm your generator: {build_generator} [y/n]: ")
|
|
if confirmation in ["y", "yes", 1]:
|
|
break
|
|
return build_generator
|
|
|
|
|
|
def determine_build_folder(cmake_build_type: str) -> str:
|
|
confirm = input(f"No build folder specified. Set to build type name {cmake_build_type}? [y/n]: ")
|
|
if confirm in ["yes", "y", 1]:
|
|
return cmake_build_type
|
|
else:
|
|
new_folder_name = input("Please enter folder name, will be created in source folder: ")
|
|
return new_folder_name
|
|
|
|
|
|
def determine_source_location() -> str:
|
|
index = 0
|
|
while not os.path.isdir("fsfw"):
|
|
index += 1
|
|
os.chdir("..")
|
|
if index >= 5:
|
|
print("Error: Could not find source directory (determined by looking for fsfw folder!)")
|
|
sys.exit(1)
|
|
return os.getcwd()
|
|
|
|
|
|
def determine_fsfw_osal() -> str:
|
|
select_dict = dict({
|
|
1: "host",
|
|
2: "linux",
|
|
3: "freertos",
|
|
4: "rtems"
|
|
})
|
|
print("No build type specified. Please select from the following list of build types: ")
|
|
for key, item in select_dict.items():
|
|
print(f"{key}: {item}")
|
|
select = input("Enter your selection: ")
|
|
while True:
|
|
if select.isdigit():
|
|
select_num = int(select)
|
|
if select_num >= 1 or select_num <= 4:
|
|
return select_dict[select_num]
|
|
else:
|
|
print("Input digit is invalid!")
|
|
else:
|
|
print("Input is not a digit!")
|
|
|
|
|
|
def determine_build_type(build_type_arg) -> str:
|
|
if build_type_arg is None:
|
|
select_dict = dict({
|
|
1: "Debug",
|
|
2: "Release",
|
|
3: "Release with Debug Information",
|
|
4: "Size"
|
|
})
|
|
print("No build type specified. Please select from the following list of build types")
|
|
for key, item in select_dict.items():
|
|
print(f"{key}: {item}")
|
|
select = input("Enter your selection: ")
|
|
while True:
|
|
if select.isdigit():
|
|
select_num = int(select)
|
|
if select_num >= 1 or select_num <= 4:
|
|
cmake_build_type = select_dict[select_num]
|
|
break
|
|
else:
|
|
print("Input digit is invalid!")
|
|
else:
|
|
print("Input is not a digit!")
|
|
else:
|
|
if build_type_arg == "debug":
|
|
cmake_build_type = "Debug"
|
|
elif build_type_arg == "release":
|
|
cmake_build_type = "Release"
|
|
elif build_type_arg == "size":
|
|
cmake_build_type = "MinSizeRel"
|
|
elif build_type_arg == "reldeb":
|
|
cmake_build_type = "RelWithDebInfo"
|
|
else:
|
|
print("Unknown buildtype.")
|
|
cmake_build_type = determine_build_type(None)
|
|
return cmake_build_type
|
|
|
|
|
|
def determine_new_folder() -> str:
|
|
new_folder = input(f"Use different folder name? [y/n]: ")
|
|
if str(new_folder).lower() in ["yes", "y", 1]:
|
|
new_folder_name = input("New folder name: ")
|
|
return new_folder_name
|
|
else:
|
|
print("Aborting configuration.")
|
|
sys.exit(0)
|
|
|
|
|
|
def determine_tgt_bsp(osal: str) -> str:
|
|
if osal == "freertos":
|
|
print("Target BSP set to arm/stm32h743zi-nucleo")
|
|
osal = "arm/stm32h743zi-nucleo"
|
|
elif osal == "linux":
|
|
print("No target BSP specified. Please select from the following list of build types.")
|
|
select_dict = dict({
|
|
1: "arm/raspberrypi",
|
|
2: "none/hosted"
|
|
})
|
|
for key, item in select_dict.items():
|
|
print(f"{key}: {item}")
|
|
select = input("Enter your selection: ")
|
|
while True:
|
|
if select.isdigit():
|
|
select_num = int(select)
|
|
if select_num >= 1 or select_num <= 2:
|
|
osal = select_dict[select_num]
|
|
break
|
|
else:
|
|
print("Input digit is invalid!")
|
|
else:
|
|
print("Input is not a digit!")
|
|
return osal
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|