import sys

import os

import argparse

import traceback

import re

import json

import pathlib

# import Mbed's built-in tools library

project_root_dir = os.path.dirname(__file__)

mbed_os_dir = os.path.join(project_root_dir, "mbed-src")

sys.path.append(mbed_os_dir)

try:

from tools import build_api, options

from tools.resources import Resources, FileType

from tools.notifier.term import TerminalNotifier

from tools.config import Config

except ImportError:

print("Failed to import the Mbed OS Python configuration system!")

print("Be sure that you have installed all required python modules, see mbed-src/requirements.txt")

traceback.print_exc()

exit(1)

def write_target_header(target_header_path:str, symbol_list:list):

target_header.close()

def build_cmake_list(list_name:str, contents:list):

return list_string

def build_cmake_path_list(list_name:str, paths:list):

return build_cmake_list(list_name, converted_paths)

def write_cmake_config(cmake_config_path:str, mcu_compile_flags:list, mcu_link_flags:list,

cmake_config.close()

# Function to print all known configuration variables.

# Based on tools/get_config.py

def print_config(print_descriptions:bool, toolchain):

print(m)

# Parse args

# -------------------------------------------------------------------------

GENERATED_DEFAULT_PATH = "../mbed-cmake-config/"

parser = argparse.ArgumentParser(description="Configure mbed-cmake for a processor target.")

parser.add_argument('target', type=str, help="Mbed target name to configure the build system for.")

parser.add_argument('-l', '--list-config', action="store_true", help="List all the config options that Mbed OS supports for your target")

parser.add_argument('-c', '--print-config', action="store_true", help="Print all the config options that Mbed OS supports for your target, with descriptions")

parser.add_argument('-p', '--generated-path', default=GENERATED_DEFAULT_PATH,

help="The relative path to the directory which will store the generated files")

parser.add_argument('-t', '--toolchain', default="GCC_ARM",

choices=["ARMC6", "GCC_ARM"],

help="Toolchain that you will be compiling with.")

args = parser.parse_args()

target_name=args.target

toolchain_name=args.toolchain

get_config=args.list_config or args.print_config

verbose_config=args.print_config

generated_rpath = args.generated_path

generated_path = os.path.join(project_root_dir, generated_rpath)

pathlib.Path(generated_path).mkdir(parents=True, exist_ok=True)

with open(os.path.join(generated_path, "do-not-modify.txt"), 'w') as do_not_modify:

do_not_modify.write("Files in this folder were generated by configure_for_target.py")

# Perform the scan of the Mbed OS dirs

# -------------------------------------------------------------------------

# profile constants

# list of all profile JSONs

profile_jsons = [os.path.join(mbed_os_dir, "tools/profiles/develop.json"),

os.path.join(mbed_os_dir, "tools/profiles/debug.json"),

os.path.join(mbed_os_dir, "tools/profiles/release.json")]

# CMake build type matching each Mbed profile

profile_cmake_names = ["RELWITHDEBINFO",

"DEBUG",

"RELEASE"]

print("Configuring build system for target " + target_name)

# Can NOT be the current directory, or it screws up some internal regexes inside mbed tools.

# That was a fun hour to debug...

config_header_dir = os.path.join(generated_path, "config-headers")

pathlib.Path(config_header_dir).mkdir(parents=True, exist_ok=True) # create dir if not exists

notifier = TerminalNotifier(True, False)

# create a different toolchain for each profile so that we can detect the flags needed in each configuration

profile_toolchains = []

for profile_json_path in profile_jsons:

with open(profile_json_path) as profile_file:

print(">> Collecting data for config " + profile_json_path)

profile_data = json.load(profile_file)

profile_toolchain = build_api.prepare_toolchain(src_paths=[mbed_os_dir], build_dir=config_header_dir, target=target_name, toolchain_name=toolchain_name, build_profile=[profile_data])

# each toolchain must then scan the mbed dir to pick up more configs

resources = Resources(notifier).scan_with_toolchain(src_paths=[mbed_os_dir], toolchain=profile_toolchain, exclude=True)

profile_toolchain.RESPONSE_FILES=False

profile_toolchains.append(profile_toolchain)

# Profiles seem to only set flags, so for the remaining operations we can use any toolchain

toolchain = profile_toolchains[0]

print("Generated config header: " + toolchain.get_config_header())

print("Using settings from these JSON files:\n " + "\n ".join(resources.get_file_paths(FileType.JSON)))

# Write target header

# -------------------------------------------------------------------------

target_header_path = os.path.join(config_header_dir, "mbed_target_config.h")

write_target_header(target_header_path, toolchain.get_symbols())

print("Generated target config header: " + target_header_path)

# Write CMake config file

# -------------------------------------------------------------------------

cmake_config_dir = os.path.join(generated_path, "cmake", )

pathlib.Path(cmake_config_dir).mkdir(parents=True, exist_ok=True) # create dir if not exists

cmake_config_path = os.path.join(cmake_config_dir, "MbedOSConfig.cmake")

# create include paths

inc_paths = resources.get_file_paths(FileType.INC_DIR)

inc_paths = set(inc_paths) # De-duplicate include paths

inc_paths = sorted(set(inc_paths)) # Sort include paths for consistency

# Get sources

sources = (

)

# common flags are the intersection of flags from all configurations

common_flags = set(toolchain.flags['common'])

common_link_flags = set(toolchain.flags['ld'])

for profile_idx in range(1, len(profile_toolchains)):

common_flags = common_flags & set(profile_toolchains[profile_idx].flags['common'])

common_link_flags = common_link_flags & set(profile_toolchains[profile_idx].flags['ld'])

# profile flags are the flags in one profile that are not in common flags.

profile_flags = []

profile_link_flags = []

for profile_idx in range(0, len(profile_toolchains)):

profile_flags.append(set(profile_toolchains[profile_idx].flags['common']) - common_flags)

profile_link_flags.append(set(profile_toolchains[profile_idx].flags['ld']) - common_link_flags)

write_cmake_config(cmake_config_path,

mcu_compile_flags=toolchain.flags['common'],

mcu_link_flags=toolchain.flags['ld'],

linker_script=resources.get_file_paths(FileType.LD_SCRIPT)[0],

include_dirs = inc_paths,

source_files = sources,

target_name = target_name,

toolchain_name=toolchain_name,

profile_flags = profile_flags,

profile_link_flags = profile_link_flags,

profile_names = profile_cmake_names)

print("Generated CMake configuration file: " + cmake_config_path)

if get_config:

print("")

print_config(verbose_config, toolchain)

print("-----------------------------------------------")

print(" mbed-cmake configuration complete.")

print("")

print(" MAKE SURE TO DELETE ANY OLD CMAKE")

print(" BUILD DIRS BEFORE RUNNING CMAKE AGAIN")

print("-----------------------------------------------")