# The project never stores a compiler package. Each machine supplies a path.
# TOOLCHAIN_DIRECTORY (CMake cache) has priority over the environment variable.
# GD32_GCC_ENV_VAR lets a workstation use a different variable name if needed.
set(TOOLCHAIN_DIRECTORY "" CACHE PATH "Path to arm-none-eabi toolchain bin directory")
set(GD32_GCC_ENV_VAR "GD32_GCC_BIN" CACHE STRING "Environment variable containing the ARM GCC path")
set(CMAKE_TRY_COMPILE_PLATFORM_VARIABLES TOOLCHAIN_DIRECTORY GD32_GCC_ENV_VAR)

if(GD32_GCC_ENV_VAR AND NOT GD32_GCC_ENV_VAR MATCHES "^GD32_[A-Za-z0-9_]+$")
    message(FATAL_ERROR "GD32_GCC_ENV_VAR must use the GD32_ prefix: ${GD32_GCC_ENV_VAR}")
endif()

if(NOT TOOLCHAIN_DIRECTORY AND GD32_GCC_ENV_VAR)
    if(DEFINED ENV{${GD32_GCC_ENV_VAR}} AND NOT "$ENV{${GD32_GCC_ENV_VAR}}" STREQUAL "")
        file(TO_CMAKE_PATH "$ENV{${GD32_GCC_ENV_VAR}}" TOOLCHAIN_DIRECTORY)
    endif()
endif()

if(NOT TOOLCHAIN_DIRECTORY)
    message(FATAL_ERROR
        "Cannot find ARM GCC toolchain. Set ${GD32_GCC_ENV_VAR} in the machine environment "
        "or pass -DTOOLCHAIN_DIRECTORY=<toolchain-bin>.")
endif()

file(TO_CMAKE_PATH "${TOOLCHAIN_DIRECTORY}" TOOLCHAIN_DIRECTORY)
get_filename_component(TOOLCHAIN_DIRECTORY "${TOOLCHAIN_DIRECTORY}" ABSOLUTE)

if(WIN32)
    set(TOOLCHAIN_SUFFIX ".exe")
else()
    set(TOOLCHAIN_SUFFIX "")
endif()

# Accept either the package root or its bin directory.
if(NOT EXISTS "${TOOLCHAIN_DIRECTORY}/arm-none-eabi-gcc${TOOLCHAIN_SUFFIX}" AND
   EXISTS "${TOOLCHAIN_DIRECTORY}/bin/arm-none-eabi-gcc${TOOLCHAIN_SUFFIX}")
    set(TOOLCHAIN_DIRECTORY "${TOOLCHAIN_DIRECTORY}/bin")
endif()

set(_ARM_GCC_EXECUTABLE "${TOOLCHAIN_DIRECTORY}/arm-none-eabi-gcc${TOOLCHAIN_SUFFIX}")

set(_TOOLCHAIN_BINARIES
    arm-none-eabi-gcc
    arm-none-eabi-g++
    arm-none-eabi-gdb
    arm-none-eabi-ar
    arm-none-eabi-ranlib
    arm-none-eabi-as
    arm-none-eabi-ld
    arm-none-eabi-objcopy
    arm-none-eabi-objdump
    arm-none-eabi-size
)
foreach(_binary IN LISTS _TOOLCHAIN_BINARIES)
    if(NOT EXISTS "${TOOLCHAIN_DIRECTORY}/${_binary}${TOOLCHAIN_SUFFIX}")
        message(FATAL_ERROR
            "ARM GCC toolchain is incomplete; missing ${_binary}${TOOLCHAIN_SUFFIX} in ${TOOLCHAIN_DIRECTORY}")
    endif()
endforeach()

set(CMAKE_C_FLAGS_DEBUG "")
set(CMAKE_CXX_FLAGS_DEBUG "")
set(CMAKE_ASM_FLAGS_DEBUG "")
set(CMAKE_C_FLAGS_RELEASE "")
set(CMAKE_CXX_FLAGS_RELEASE "")
set(CMAKE_ASM_FLAGS_RELEASE "")

set(CMAKE_COLOR_DIAGNOSTICS ON)

set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE INTERNAL "")

set(CMAKE_SYSTEM_NAME               Generic)
set(CMAKE_SYSTEM_PROCESSOR          arm)

set(TOOLCHAIN_PREFIX                "arm-none-eabi-")
if(DEFINED TOOLCHAIN_DIRECTORY)
    set(TOOLCHAIN_PREFIX            "${TOOLCHAIN_DIRECTORY}/${TOOLCHAIN_PREFIX}")
endif()

set(FLAGS                           "-mcpu=cortex-m23 -std=gnu11 -fstack-usage -fdata-sections -ffunction-sections -fmessage-length=0 -fsigned-char -mthumb -Wall -Wno-missing-braces -Wno-format -Wno-strict-aliasing -Wl,--gc-sections")
set(ASM_FLAGS                       "-x assembler-with-cpp")
set(CPP_FLAGS                       "-fno-rtti -fno-exceptions -fno-threadsafe-statics")

set(_REQUESTED_C_COMPILER "${TOOLCHAIN_PREFIX}gcc${TOOLCHAIN_SUFFIX}")
if(DEFINED CMAKE_C_COMPILER AND CMAKE_C_COMPILER AND
   IS_ABSOLUTE "${CMAKE_C_COMPILER}" AND
   NOT CMAKE_C_COMPILER STREQUAL "${_REQUESTED_C_COMPILER}")
    message(FATAL_ERROR
        "The build directory is already configured for a different ARM GCC compiler:\n"
        "  cached:  ${CMAKE_C_COMPILER}\n"
        "  selected: ${_REQUESTED_C_COMPILER}\n"
        "Delete the build directory or run CMake Tools 'Delete Cache and Reconfigure'.")
endif()

set(CMAKE_C_COMPILER                "${_REQUESTED_C_COMPILER}")
set(CMAKE_CXX_COMPILER              "${TOOLCHAIN_PREFIX}g++${TOOLCHAIN_SUFFIX}")
set(CMAKE_ASM_COMPILER              "${TOOLCHAIN_PREFIX}gcc${TOOLCHAIN_SUFFIX}")

set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLAGS} ${CPP_FLAGS}")
set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} ${FLAGS} ${ASM_FLAGS}")
set(CMAKE_AR                        "${TOOLCHAIN_PREFIX}ar${TOOLCHAIN_SUFFIX}")
set(CMAKE_RANLIB                    "${TOOLCHAIN_PREFIX}ranlib${TOOLCHAIN_SUFFIX}")
set(CMAKE_OBJCOPY                   "${TOOLCHAIN_PREFIX}objcopy${TOOLCHAIN_SUFFIX}")
set(CMAKE_SIZE                      "${TOOLCHAIN_PREFIX}size${TOOLCHAIN_SUFFIX}")
set(CMAKE_OBJDUMP                   "${TOOLCHAIN_PREFIX}objdump${TOOLCHAIN_SUFFIX}")
set(CMAKE_AS                        "${TOOLCHAIN_PREFIX}as${TOOLCHAIN_SUFFIX}")
set(CMAKE_LD                        "${TOOLCHAIN_PREFIX}ld${TOOLCHAIN_SUFFIX}")
set(CMAKE_LINKER                   "${TOOLCHAIN_PREFIX}ld${TOOLCHAIN_SUFFIX}")

execute_process(
    COMMAND "${_ARM_GCC_EXECUTABLE}" --version
    OUTPUT_VARIABLE _ARM_GCC_VERSION_OUTPUT
    ERROR_VARIABLE _ARM_GCC_VERSION_ERROR
    RESULT_VARIABLE _ARM_GCC_VERSION_RESULT
    OUTPUT_STRIP_TRAILING_WHITESPACE
)
if(NOT _ARM_GCC_VERSION_RESULT EQUAL 0)
    message(FATAL_ERROR "Unable to execute ${_ARM_GCC_EXECUTABLE}: ${_ARM_GCC_VERSION_ERROR}")
endif()
string(REGEX MATCH "[0-9]+\\.[0-9]+\\.[0-9]+" _ARM_GCC_VERSION "${_ARM_GCC_VERSION_OUTPUT}")
message(STATUS "Using ARM GCC ${_ARM_GCC_VERSION} from ${TOOLCHAIN_DIRECTORY}")

set(CMAKE_EXECUTABLE_SUFFIX_ASM     ".elf")
set(CMAKE_EXECUTABLE_SUFFIX_C       ".elf")
set(CMAKE_EXECUTABLE_SUFFIX_CXX     ".elf")

set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)