1125 lines
44 KiB
CMake
1125 lines
44 KiB
CMake
cmake_minimum_required(VERSION 3.20)
|
|
|
|
if (WIN32)
|
|
set(CPACK_GENERATOR "ZIP")
|
|
else()
|
|
set(CPACK_GENERATOR "TGZ")
|
|
endif()
|
|
set(CPACK_VERBATIM_VARIABLES YES)
|
|
include(CPack)
|
|
|
|
|
|
## fist step is determining the target:
|
|
if (WIN32)
|
|
set(GLD_TARGET "Windows" CACHE INTERNAL "")
|
|
elseif(APPLE)
|
|
set(GLD_TARGET "MacOs" CACHE INTERNAL "")
|
|
elseif(LINUX)
|
|
set(GLD_TARGET "Linux" CACHE INTERNAL "")
|
|
elseif(UNIX AND NOT APPLE)
|
|
set(GLD_TARGET "Linux" CACHE INTERNAL "")
|
|
else()
|
|
message("GLD Can not determine the target !!!")
|
|
exit(-1)
|
|
endif()
|
|
|
|
if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
|
|
set(GLD_COMPILATOR "clang" CACHE INTERNAL "")
|
|
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
|
|
set(GLD_COMPILATOR "gcc" CACHE INTERNAL "")
|
|
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
|
|
set(GLD_COMPILATOR "intel" CACHE INTERNAL "")
|
|
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
|
|
set(GLD_COMPILATOR "msvc" CACHE INTERNAL "")
|
|
else()
|
|
message("GLD Can not determine the compilator !!!")
|
|
exit(-1)
|
|
endif()
|
|
|
|
if(CMAKE_BUILD_TYPE STREQUAL "Debug")
|
|
set(GLD_MODE "debug" CACHE INTERNAL "")
|
|
elseif(CMAKE_BUILD_TYPE STREQUAL "debug")
|
|
set(GLD_MODE "debug" CACHE INTERNAL "")
|
|
else()
|
|
set(GLD_MODE "release" CACHE INTERNAL "")
|
|
endif()
|
|
|
|
|
|
if(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64"
|
|
OR CMAKE_SYSTEM_PROCESSOR STREQUAL amd64)
|
|
set(GLD_ARCH "x86" CACHE INTERNAL "")
|
|
set(GLD_BUS_SIZE "64" CACHE INTERNAL "")
|
|
elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86"
|
|
OR CMAKE_SYSTEM_PROCESSOR STREQUAL "i686")
|
|
set(GLD_ARCH "x86" CACHE INTERNAL "")
|
|
set(GLD_BUS_SIZE "32" CACHE INTERNAL "")
|
|
elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "ppc64")
|
|
set(GLD_ARCH "ppc" CACHE INTERNAL "")
|
|
set(GLD_BUS_SIZE "64" CACHE INTERNAL "")
|
|
elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "ppc")
|
|
set(GLD_ARCH "ppc" CACHE INTERNAL "")
|
|
set(GLD_BUS_SIZE "32" CACHE INTERNAL "")
|
|
elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64"
|
|
OR CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64")
|
|
set(GLD_ARCH "arm" CACHE INTERNAL "")
|
|
set(GLD_BUS_SIZE "64" CACHE INTERNAL "")
|
|
elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "arm"
|
|
OR CMAKE_SYSTEM_PROCESSOR STREQUAL "armv7l"
|
|
OR CMAKE_SYSTEM_PROCESSOR STREQUAL "armv9")
|
|
set(GLD_ARCH "arm" CACHE INTERNAL "")
|
|
set(GLD_BUS_SIZE "32" CACHE INTERNAL "")
|
|
else()
|
|
message("GLD Can not determine the architecture and bus-size !!!")
|
|
exit(-1)
|
|
endif()
|
|
|
|
# cmake does not support other mode than "intricate" the "isolate" mode is too much complicated to do.
|
|
set(GLD_SANITY_MODE "intricate" CACHE INTERNAL "")
|
|
# list of current supported language:
|
|
# - 'c': C language
|
|
# - 'c++': C++ language
|
|
# - 'asm': asembler language
|
|
# - 'm': Objective-C language
|
|
# - 'mm': Objective-C++ language
|
|
# - 'java': Java language
|
|
# - 'javah': generated c header with Java description (for JNI)
|
|
# TODO: maybe permit user to add some other... like "in", "masm", or other pre-step generation code???
|
|
set(GLD_SUPPORT_LANGUAGE "c;asm;c++;m;mm;java;javah" CACHE INTERNAL "")
|
|
set(GLD_SUPPORT_LANGUAGE_VARIABLE "C;ASM;CXX;M;MM;JAVA;JAVAH" CACHE INTERNAL "")
|
|
set(GLD_LANGUAGE_EXTENTION_C "c;C" CACHE INTERNAL "")
|
|
set(GLD_LANGUAGE_EXTENTION_CXX "cpp;CPP;cxx;CXX" CACHE INTERNAL "")
|
|
set(GLD_LANGUAGE_EXTENTION_ASM "s;S" CACHE INTERNAL "")
|
|
set(GLD_LANGUAGE_EXTENTION_M "m;M" CACHE INTERNAL "")
|
|
set(GLD_LANGUAGE_EXTENTION_MM "mm;MM" CACHE INTERNAL "")
|
|
set(GLD_LANGUAGE_EXTENTION_JAVA "java" CACHE INTERNAL "")
|
|
set(GLD_LANGUAGE_EXTENTION_JAVAH "javah" CACHE INTERNAL "")
|
|
|
|
# where is build the module
|
|
set(GLD_GLOBAL_BUILD_FOLDER "${CMAKE_CURRENT_BINARY_DIR}/${GLD_TARGET}_${GLD_ARCH}_${GLD_BUS_SIZE}/${GLD_MODE}/build/${GLD_COMPILATOR}/" CACHE INTERNAL "")
|
|
# where the package is prepared
|
|
set(GLD_GLOBAL_STAGING_FOLDER "${CMAKE_CURRENT_BINARY_DIR}/${GLD_TARGET}_${GLD_ARCH}_${GLD_BUS_SIZE}/${GLD_MODE}/staging/${GLD_COMPILATOR}/" CACHE INTERNAL "")
|
|
# whe the bundle (tar, jar ...) is set
|
|
set(GLD_GLOBAL_FINAL_FOLDER "${CMAKE_CURRENT_BINARY_DIR}/${GLD_TARGET}_${GLD_ARCH}_${GLD_BUS_SIZE}/${GLD_MODE}/final/${GLD_COMPILATOR}/" CACHE INTERNAL "")
|
|
|
|
message("Global GLD properties:")
|
|
message(" GLD_MODE : ${GLD_MODE}")
|
|
message(" GLD_COMPILATOR : ${GLD_COMPILATOR}")
|
|
message(" GLD_TARGET : ${GLD_TARGET}")
|
|
message(" GLD_ARCH : ${GLD_ARCH}")
|
|
message(" GLD_BUS_SIZE : ${GLD_BUS_SIZE}")
|
|
message(" GLD_SANITY_MODE : ${GLD_SANITY_MODE}")
|
|
message(" GLD_GLOBAL_BUILD_FOLDER : ${GLD_GLOBAL_BUILD_FOLDER}")
|
|
message(" GLD_GLOBAL_STAGING_FOLDER : ${GLD_GLOBAL_STAGING_FOLDER}")
|
|
message(" GLD_GLOBAL_FINAL_FOLDER : ${GLD_GLOBAL_FINAL_FOLDER}")
|
|
|
|
##
|
|
## @brief get the type of a variable
|
|
## @param[in] INPUT_JSON Json data.
|
|
## @param[in] VARIABLE Name of the variable.
|
|
## @param[out] OUT_VAR Retrun type of the node: NULL, NUMBER, STRING, BOOLEAN, ARRAY, OBJECT or NOTFOUND (if does not exist)
|
|
##
|
|
function(json_get_type OUT_VAR INPUT_JSON VARIABLE)
|
|
string(JSON VALUE ERROR_VARIABLE ${VARIABLE} TYPE ${INPUT_JSON} ${VARIABLE})
|
|
if (${VALUE} STREQUAL ${VARIABLE}-NOTFOUND)
|
|
set(${OUT_VAR} "NOTFOUND" PARENT_SCOPE)
|
|
else()
|
|
set(${OUT_VAR} "${VALUE}" PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
|
|
function(json_size OUT_VAR INPUT_JSON VARIABLE)
|
|
string(JSON VALUE ERROR_VARIABLE ${VARIABLE} LENGTH ${INPUT_JSON} ${VARIABLE})
|
|
if (${VALUE} STREQUAL ${VARIABLE}-NOTFOUND)
|
|
set("${OUT_VAR}" 0 PARENT_SCOPE)
|
|
else ()
|
|
set("${OUT_VAR}" ${VALUE} PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
function(json_get_data OUT_VAR INPUT_JSON VARIABLE)
|
|
string(JSON VALUE GET ${INPUT_JSON} ${VARIABLE})
|
|
set("${OUT_VAR}" ${VALUE} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
function(json_object_key OUT_VAR INPUT_JSON IDX)
|
|
string(JSON VALUE MEMBER ${INPUT_JSON} ${IDX})
|
|
set("${OUT_VAR}" ${VALUE} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
function(json_object_keys OUT_VAR MY_JSON_STRING VARIABLE)
|
|
json_size(SIZE ${MY_JSON_STRING} ${VARIABLE})
|
|
#message("target SIZE = ${SIZE}")
|
|
json_get_data(OBJECT_DATA ${MY_JSON_STRING} ${VARIABLE})
|
|
MATH(EXPR SIZE "${SIZE}-1")
|
|
set(OUT "")
|
|
foreach(IDX RANGE ${SIZE})
|
|
json_object_key(ELEMENT ${OBJECT_DATA} ${IDX})
|
|
#message(" - : ${ELEMENT}")
|
|
list(APPEND OUT ${ELEMENT})
|
|
endforeach()
|
|
set("${OUT_VAR}" ${OUT} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
function(json_object_values OUT_VAR INPUT_JSON VARIABLE KEYS)
|
|
string(JSON VALUE GET ${INPUT_JSON} ${VARIABLE} ${KEYS})
|
|
set("${OUT_VAR}" ${VALUE} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
function(json_get_list OUT_VAR INPUT_JSON VARIABLE)
|
|
string(JSON LIST_JSON_ELEMENTS ERROR_VARIABLE ${VARIABLE} GET ${INPUT_JSON} ${VARIABLE})
|
|
if (${LIST_JSON_ELEMENTS} STREQUAL ${VARIABLE}-NOTFOUND)
|
|
set("${OUT_VAR}" PARENT_SCOPE)
|
|
retrun()
|
|
endif()
|
|
#message("LIST_JSON_ELEMENTS : ${LIST_JSON_ELEMENTS}")
|
|
|
|
string(JSON LENGTH_VALUE LENGTH ${LIST_JSON_ELEMENTS})
|
|
#message("LENGTH_VALUE : ${LENGTH_VALUE}")
|
|
if (${LENGTH_VALUE} EQUAL 0)
|
|
set("${OUT_VAR}" PARENT_SCOPE)
|
|
retrun()
|
|
endif()
|
|
set(OUT_LIST)
|
|
MATH(EXPR LENGTH_VALUE "${LENGTH_VALUE}-1")
|
|
foreach(IDX RANGE ${LENGTH_VALUE})
|
|
string(JSON ELEM GET ${LIST_JSON_ELEMENTS} ${IDX})
|
|
#message(" - : ${ELEM}")
|
|
list(APPEND OUT_LIST ${ELEM})
|
|
endforeach()
|
|
#message("OUT_LIST : ${OUT_LIST}")
|
|
set("${OUT_VAR}" ${OUT_LIST} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
|
|
|
|
function(json_get_element OUT_VAR INPUT_JSON VARIABLE)
|
|
string(JSON ELEMENT ERROR_VARIABLE ${VARIABLE} GET ${INPUT_JSON} ${VARIABLE})
|
|
if ("${ELEMENT}" STREQUAL "${VARIABLE}-NOTFOUND")
|
|
set("${OUT_VAR}" "" PARENT_SCOPE)
|
|
elseif ("${ELEMENT}" STREQUAL "NOTFOUND")
|
|
set("${OUT_VAR}" "" PARENT_SCOPE)
|
|
else()
|
|
set("${OUT_VAR}" ${ELEMENT} PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
|
|
|
|
function(GLD_import_full_group NAME_GLD_MODULE MY_JSON_STRING ELEMENT_TO_CHECK TYPE_VARIABLE)
|
|
json_get_type(TYPE ${MY_JSON_STRING} ${ELEMENT_TO_CHECK})
|
|
#message("target type = ${TYPE}")
|
|
if (${TYPE} STREQUAL "OBJECT")
|
|
json_object_keys(LIST_KEY ${MY_JSON_STRING} ${ELEMENT_TO_CHECK})
|
|
foreach (III ${LIST_KEY})
|
|
# check the target, no need to had unknown target ...
|
|
if (${III} STREQUAL "*")
|
|
json_object_values(DATA_TARGET ${MY_JSON_STRING} ${ELEMENT_TO_CHECK} "*")
|
|
#message("target(*) data: ${DATA_TARGET}")
|
|
GLD_import_full(NAME_GLD_MODULE DATA_TARGET)
|
|
elseif (${III} STREQUAL ${TYPE_VARIABLE})
|
|
json_object_values(DATA_TARGET ${MY_JSON_STRING} ${ELEMENT_TO_CHECK} "${III}")
|
|
GLD_import_full(NAME_GLD_MODULE DATA_TARGET)
|
|
#message("target(${III}) data: ${DATA_TARGET}")
|
|
else()
|
|
message("TODO: get dependency manage '${ELEMENT_TO_CHECK}' : ${III}")
|
|
endif()
|
|
endforeach()
|
|
elseif(${TYPE} STREQUAL "NOTFOUND" OR ${TYPE} STREQUAL "NULL")
|
|
# nothing to do ..
|
|
else()
|
|
message("ERROR : '${ELEMENT_TO_CHECK}' can not be other than an json object : ${TYPE}")
|
|
endif()
|
|
endfunction()
|
|
|
|
|
|
function(GLD_import_element_dependency NAME_GLD_MODULE MY_JSON_STRING)
|
|
GLD_get_module_name(LOCAL_MODULE_NAME ${NAME_GLD_MODULE})
|
|
##########################################################
|
|
## DEPENDENCY:
|
|
##########################################################
|
|
json_get_type(TYPE ${MY_JSON_STRING} "dependency")
|
|
set(LIST_VALUE "")
|
|
set(LIST_OPTIONAL_VALUE "")
|
|
#message("Dependency type = ${TYPE}")
|
|
if (${TYPE} STREQUAL "ARRAY")
|
|
json_size(SIZE ${MY_JSON_STRING} "dependency")
|
|
#message("Dependency SIZE = ${SIZE}")
|
|
json_get_data(OBJECT_DATA ${MY_JSON_STRING} "dependency")
|
|
MATH(EXPR SIZE "${SIZE}-1")
|
|
set(VAR_OUT_TMP "")
|
|
foreach(IDX RANGE ${SIZE})
|
|
json_get_data(ELEMENT ${OBJECT_DATA} ${IDX})
|
|
json_get_type(TYPE ${OBJECT_DATA} ${IDX})
|
|
if (${TYPE} STREQUAL "STRING")
|
|
message(" - <dep> : ${ELEMENT}")
|
|
list(APPEND VAR_OUT_TMP ${ELEMENT})
|
|
elseif (${TYPE} STREQUAL "OBJECT")
|
|
json_get_type(TYPE ${ELEMENT} "name")
|
|
if (${TYPE} STREQUAL "STRING")
|
|
json_get_data(DEPENDENCY_NAME ${ELEMENT} "name")
|
|
json_get_type(TYPE ${ELEMENT} "optional")
|
|
#message("optional type = ${TYPE} <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ${DEPENDENCY_NAME}")
|
|
if (${TYPE} STREQUAL "BOOLEAN")
|
|
json_get_data(DEPENDENCY_OPTIONAL ${ELEMENT} "optional")
|
|
if (${DEPENDENCY_OPTIONAL})
|
|
message(" - <dep> : ${DEPENDENCY_NAME} (optional) ==> not managed now ...")
|
|
#message("optional value ==========================> '${DEPENDENCY_OPTIONAL}' ==> MAYBE")
|
|
list(APPEND LIST_OPTIONAL_VALUE ${DEPENDENCY_NAME})
|
|
else()
|
|
message(" - <dep> : ${DEPENDENCY_NAME}")
|
|
#message("optional value ==========================> '${DEPENDENCY_OPTIONAL}' ==> MUST")
|
|
list(APPEND VAR_OUT_TMP ${DEPENDENCY_NAME})
|
|
endif()
|
|
else()
|
|
message(" - <dep> : ${DEPENDENCY_NAME}")
|
|
list(APPEND VAR_OUT_TMP ${DEPENDENCY_NAME})
|
|
endif()
|
|
#message("optional type = ${TYPE} <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ${DEPENDENCY_NAME}")
|
|
else()
|
|
message("Dependency 'name' is not a string or is missing type: ${TYPE}")
|
|
endif()
|
|
else()
|
|
message("dependency element not manage data : ${ELEMENT}")
|
|
## TODO add in dependency if optional : check if the element exit in the current module list ...
|
|
|
|
endif()
|
|
endforeach()
|
|
list(APPEND LIST_VALUE ${VAR_OUT_TMP})
|
|
elseif(${TYPE} STREQUAL "NOTFOUND")
|
|
return()
|
|
endif()
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY ${MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY} ${LIST_VALUE} CACHE INTERNAL "")
|
|
|
|
endfunction()
|
|
|
|
function(GLD_import_element_source NAME_GLD_MODULE MY_JSON_STRING)
|
|
GLD_get_module_name(LOCAL_MODULE_NAME ${NAME_GLD_MODULE})
|
|
##########################################################
|
|
## SOURCE:
|
|
##########################################################
|
|
set(LIST_VALUE "")
|
|
json_get_type(TYPE ${MY_JSON_STRING} "source")
|
|
if (${TYPE} STREQUAL "STRING")
|
|
json_get_data(OBJECT_DATA ${MY_JSON_STRING} "source")
|
|
message(" - <src> : ${OBJECT_DATA}")
|
|
list(APPEND LIST_VALUE ${OBJECT_DATA})
|
|
elseif (${TYPE} STREQUAL "ARRAY")
|
|
json_get_data(OBJECT_DATA ${MY_JSON_STRING} "source")
|
|
json_size(SIZE ${MY_JSON_STRING} "source")
|
|
#message("Dependency SIZE = ${SIZE}")
|
|
MATH(EXPR SIZE "${SIZE}-1")
|
|
set(VAR_OUT_TMP "")
|
|
foreach(IDX RANGE ${SIZE})
|
|
json_get_data(ELEMENT ${OBJECT_DATA} ${IDX})
|
|
json_get_type(TYPE ${OBJECT_DATA} ${IDX})
|
|
if (${TYPE} STREQUAL "STRING")
|
|
message(" - <src> : ${ELEMENT}")
|
|
list(APPEND LIST_VALUE ${ELEMENT})
|
|
elseif (${TYPE} STREQUAL "OBJECT")
|
|
json_get_type(TYPE ${ELEMENT} "source")
|
|
json_get_data(ELEMENT_SOURCE ${ELEMENT} "source")
|
|
if (${TYPE} STREQUAL "STRING")
|
|
message(" - <src> : ${ELEMENT_SOURCE}")
|
|
list(APPEND LIST_VALUE ${ELEMENT_SOURCE})
|
|
#message("optional type = ${TYPE} <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ${DEPENDENCY_NAME}")
|
|
elseif (${TYPE} STREQUAL "ARRAY")
|
|
message(" - <src> : ${ELEMENT_SOURCE}")
|
|
list(APPEND LIST_VALUE ${ELEMENT_SOURCE})
|
|
else()
|
|
message("Dependency 'name' is not a string or is missing type: ${TYPE}")
|
|
endif()
|
|
# TODO: add the source specific flags or other things ...
|
|
else()
|
|
message("'source' element not manage data : ${ELEMENT}")
|
|
## TODO add in dependency if optional : check if the element exit in the current module list ...
|
|
endif()
|
|
endforeach()
|
|
elseif (${TYPE} STREQUAL "OBJECT")
|
|
# todo: manage object with source like { "c++":[...]...}
|
|
elseif(${TYPE} STREQUAL "NOTFOUND")
|
|
return()
|
|
else()
|
|
message(WARNING "Unmanaged type='${TYPE}' for 'source' node")
|
|
endif()
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_SOURCE ${MODULE_MAP_${LOCAL_MODULE_NAME}_SOURCE} ${LIST_VALUE} CACHE INTERNAL "")
|
|
endfunction()
|
|
|
|
function(GLD_import_element_header NAME_GLD_MODULE MY_JSON_STRING)
|
|
GLD_get_module_name(LOCAL_MODULE_NAME ${NAME_GLD_MODULE})
|
|
##########################################################
|
|
## HEADER:
|
|
##########################################################
|
|
set(LIST_VALUE "")
|
|
json_get_type(TYPE ${MY_JSON_STRING} "header")
|
|
if (${TYPE} STREQUAL "STRING")
|
|
json_get_data(OBJECT_DATA ${MY_JSON_STRING} "header")
|
|
message(" - <header> : ${OBJECT_DATA}")
|
|
list(APPEND LIST_VALUE ${OBJECT_DATA})
|
|
elseif (${TYPE} STREQUAL "ARRAY")
|
|
json_get_data(OBJECT_DATA ${MY_JSON_STRING} "header")
|
|
json_size(SIZE ${MY_JSON_STRING} "header")
|
|
#message("Dependency SIZE = ${SIZE}")
|
|
MATH(EXPR SIZE "${SIZE}-1")
|
|
set(VAR_OUT_TMP "")
|
|
foreach(IDX RANGE ${SIZE})
|
|
json_get_data(ELEMENT ${OBJECT_DATA} ${IDX})
|
|
json_get_type(TYPE ${OBJECT_DATA} ${IDX})
|
|
if (${TYPE} STREQUAL "STRING")
|
|
message(" - <header> : ${ELEMENT}")
|
|
list(APPEND LIST_VALUE ${ELEMENT})
|
|
elseif (${TYPE} STREQUAL "OBJECT")
|
|
json_get_type(TYPE ${ELEMENT} "source")
|
|
json_get_data(ELEMENT_SOURCE ${ELEMENT} "source")
|
|
if (${TYPE} STREQUAL "STRING")
|
|
message(" - <header> : ${ELEMENT_SOURCE}")
|
|
list(APPEND LIST_VALUE ${ELEMENT_SOURCE})
|
|
#message("optional type = ${TYPE} <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ${DEPENDENCY_NAME}")
|
|
elseif (${TYPE} STREQUAL "ARRAY")
|
|
message(" - <header> : ${ELEMENT_SOURCE}")
|
|
list(APPEND LIST_VALUE ${ELEMENT_SOURCE})
|
|
else()
|
|
message("Dependency 'name' is not a string or is missing type: ${TYPE}")
|
|
endif()
|
|
# TODO: add the source specific flags or other things ...
|
|
else()
|
|
message("'header' element not manage data : ${ELEMENT}")
|
|
## TODO add in dependency if optional : check if the element exit in the current module list ...
|
|
endif()
|
|
endforeach()
|
|
elseif (${TYPE} STREQUAL "OBJECT")
|
|
json_get_data(OBJECT_DATA ${MY_JSON_STRING} "header")
|
|
# todo: manage object with source like { "c++":[...]...}
|
|
elseif(${TYPE} STREQUAL "NOTFOUND")
|
|
return()
|
|
else()
|
|
message(WARNING "Unmanaged type='${TYPE}' for 'header' node")
|
|
endif()
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_HEADER ${MODULE_MAP_${LOCAL_MODULE_NAME}_HEADER} ${LIST_VALUE} CACHE INTERNAL "")
|
|
endfunction()
|
|
|
|
function(GLD_import_element_path NAME_GLD_MODULE MY_JSON_STRING)
|
|
GLD_get_module_name(LOCAL_MODULE_NAME ${NAME_GLD_MODULE})
|
|
##########################################################
|
|
## PATH:
|
|
##########################################################
|
|
set(LIST_VALUE "")
|
|
json_get_type(TYPE ${MY_JSON_STRING} "path")
|
|
if (${TYPE} STREQUAL "STRING")
|
|
json_get_data(OBJECT_DATA ${MY_JSON_STRING} "path")
|
|
message(" - <header> : ${OBJECT_DATA}")
|
|
list(APPEND LIST_VALUE ${OBJECT_DATA})
|
|
elseif (${TYPE} STREQUAL "ARRAY")
|
|
json_get_data(OBJECT_DATA ${MY_JSON_STRING} "path")
|
|
json_size(SIZE ${MY_JSON_STRING} "path")
|
|
#message("Dependency SIZE = ${SIZE}")
|
|
MATH(EXPR SIZE "${SIZE}-1")
|
|
set(VAR_OUT_TMP "")
|
|
foreach(IDX RANGE ${SIZE})
|
|
json_get_data(ELEMENT ${OBJECT_DATA} ${IDX})
|
|
json_get_type(TYPE ${OBJECT_DATA} ${IDX})
|
|
if (${TYPE} STREQUAL "STRING")
|
|
message(" - <header> : ${ELEMENT}")
|
|
list(APPEND LIST_VALUE ${ELEMENT})
|
|
else()
|
|
message("'path' element not manage data : ${ELEMENT}")
|
|
## TODO add in dependency if optional : check if the element exit in the current module list ...
|
|
endif()
|
|
endforeach()
|
|
elseif (${TYPE} STREQUAL "OBJECT")
|
|
json_get_data(OBJECT_DATA ${MY_JSON_STRING} "path")
|
|
# todo: manage object with source like { "c++":[...]...}
|
|
elseif(${TYPE} STREQUAL "NOTFOUND")
|
|
return()
|
|
else()
|
|
message(WARNING "Unmanaged type='${TYPE}' for 'path' node")
|
|
endif()
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_INCLUDE_LOCAL ${MODULE_MAP_${LOCAL_MODULE_NAME}_INCLUDE_LOCAL} ${LIST_VALUE} CACHE INTERNAL "")
|
|
endfunction()
|
|
|
|
function(GLD_import_element_compilation_version NAME_GLD_MODULE MY_JSON_STRING)
|
|
GLD_get_module_name(LOCAL_MODULE_NAME ${NAME_GLD_MODULE})
|
|
##########################################################
|
|
## COMPILATION-VERSION:
|
|
##########################################################
|
|
|
|
endfunction()
|
|
|
|
function(GLD_import_element_copy NAME_GLD_MODULE MY_JSON_STRING)
|
|
GLD_get_module_name(LOCAL_MODULE_NAME ${NAME_GLD_MODULE})
|
|
##########################################################
|
|
## COPY:
|
|
##########################################################
|
|
|
|
endfunction()
|
|
|
|
##
|
|
## @brief Get the list of all dependency even if they are optional.
|
|
## @param[out] VAR_OUT list of dependency library
|
|
## @param[out] VAR_OPTIONAL_OUT list of optional dependency library
|
|
## @param[in] MY_JSON_STRING Json string
|
|
## @note This function is dependent of the target
|
|
##
|
|
function(GLD_import_full NAME_GLD_MODULE MY_JSON_STRING)
|
|
GLD_import_element_dependency(${NAME_GLD_MODULE} ${MY_JSON_STRING})
|
|
GLD_import_element_source(${NAME_GLD_MODULE} ${MY_JSON_STRING})
|
|
GLD_import_element_header(${NAME_GLD_MODULE} ${MY_JSON_STRING})
|
|
GLD_import_element_path(${NAME_GLD_MODULE} ${MY_JSON_STRING})
|
|
GLD_import_element_compilation_version(${NAME_GLD_MODULE} ${MY_JSON_STRING})
|
|
GLD_import_element_copy(${NAME_GLD_MODULE} ${MY_JSON_STRING})
|
|
|
|
GLD_import_full_group(${NAME_GLD_MODULE} ${MY_JSON_STRING} "target" ${GLD_TARGET})
|
|
|
|
GLD_import_full_group(${NAME_GLD_MODULE} ${MY_JSON_STRING} "mode" ${GLD_MODE})
|
|
|
|
GLD_import_full_group(${NAME_GLD_MODULE} ${MY_JSON_STRING} "arch" ${GLD_ARCH})
|
|
|
|
GLD_import_full_group(${NAME_GLD_MODULE} ${MY_JSON_STRING} "bus-size" ${GLD_BUS_SIZE})
|
|
|
|
GLD_import_full_group(${NAME_GLD_MODULE} ${MY_JSON_STRING} "compilator" ${GLD_COMPILATOR})
|
|
|
|
GLD_import_full_group(${NAME_GLD_MODULE} ${MY_JSON_STRING} "sanity-compilation" ${GLD_SANITY_MODE})
|
|
|
|
endfunction()
|
|
|
|
|
|
function(GLD_load_from_file_if_needed VAR_OUT LIBRARY_PATH ELEMENT)
|
|
#message("Check element: ${ELEMENT}")
|
|
if("${ELEMENT}" MATCHES "file://*")
|
|
#message("match file://")
|
|
string(REPLACE "file://" "" FILENAME ${ELEMENT})
|
|
#message(" ==> ${FILENAME}")
|
|
file (STRINGS "${LIBRARY_PATH}/${FILENAME}" DATA_READ)
|
|
set(${VAR_OUT} "${DATA_READ}" PARENT_SCOPE)
|
|
else()
|
|
set(${VAR_OUT} "${ELEMENT}" PARENT_SCOPE)
|
|
endif()
|
|
endfunction()
|
|
|
|
function(GLD_import NAME_GLD_MODULE)
|
|
GLD_get_module_name(LOCAL_MODULE_NAME ${NAME_GLD_MODULE})
|
|
|
|
|
|
# set(MODULE_MAP_${LOCAL_MODULE_NAME}_FOLDER ${FOLDER} CACHE INTERNAL "")
|
|
# set(MODULE_MAP_${LOCAL_MODULE_NAME}_FILENAME ${FILENAME} CACHE INTERNAL "")
|
|
# set(MODULE_MAP_${LOCAL_MODULE_NAME}_NAME ${NAME_GLD_MODULE} CACHE INTERNAL "")
|
|
# set(MODULE_MAP_LIST ${MODULE_MAP_LIST} ${NAME_GLD_MODULE} CACHE INTERNAL "")
|
|
# Read the JSON file.
|
|
set(MY_JSON_STRING ${MODULE_MAP_${LOCAL_MODULE_NAME}_JSON})
|
|
|
|
# Loop through each element of the JSON array (indices 0 though 1).
|
|
|
|
json_get_element(LIBRARY_TYPE ${MY_JSON_STRING} "type")
|
|
json_get_element(LIBRARY_SUB_TYPE ${MY_JSON_STRING} "sub-type")
|
|
json_get_element(LIBRARY_GROUP_ID ${MY_JSON_STRING} "group-id")
|
|
json_get_element(LIBRARY_DECRIPTION ${MY_JSON_STRING} "description")
|
|
json_get_element(LIBRARY_LICENCE ${MY_JSON_STRING} "license")
|
|
json_get_element(LIBRARY_LICENCE_FILE ${MY_JSON_STRING} "license-file")
|
|
json_get_element(LIBRARY_MAINTAINER ${MY_JSON_STRING} "maintainer")
|
|
json_get_element(LIBRARY_AUTHORS ${MY_JSON_STRING} "author")
|
|
json_get_element(LIBRARY_VERSION ${MY_JSON_STRING} "version")
|
|
json_get_element(CODE_QUALITY ${MY_JSON_STRING} "code-quality")
|
|
|
|
message("LIBRARY : ${LIBRARY_GROUP_ID}:${NAME_GLD_MODULE}")
|
|
message("LIBRARY_TYPE : ${LIBRARY_TYPE} / ${LIBRARY_SUB_TYPE}")
|
|
message("LIBRARY_DECRIPTION : ${LIBRARY_DECRIPTION}")
|
|
message("LIBRARY_LICENCE : ${LIBRARY_LICENCE}")
|
|
if (LIBRARY_LICENCE_FILE)
|
|
message("LIBRARY_LICENCE_FILE : ${LIBRARY_LICENCE_FILE}")
|
|
#GLD_load_from_file_if_needed(LIBRARY_LICENCE_FILE "${MODULE_MAP_${LOCAL_MODULE_NAME}_FOLDER}" "${LIBRARY_LICENCE_FILE}")
|
|
#message(" ==> : ${LIBRARY_LICENCE_FILE}")
|
|
endif()
|
|
if (LIBRARY_MAINTAINER)
|
|
message("LIBRARY_MAINTAINER : ${LIBRARY_MAINTAINER}")
|
|
GLD_load_from_file_if_needed(LIBRARY_MAINTAINER "${MODULE_MAP_${LOCAL_MODULE_NAME}_FOLDER}" "${LIBRARY_MAINTAINER}")
|
|
message(" ==> : ${LIBRARY_MAINTAINER}")
|
|
endif()
|
|
if (LIBRARY_AUTHORS)
|
|
message("LIBRARY_AUTHORS : ${LIBRARY_AUTHORS}")
|
|
GLD_load_from_file_if_needed(LIBRARY_AUTHORS "${MODULE_MAP_${LOCAL_MODULE_NAME}_FOLDER}" "${LIBRARY_AUTHORS}")
|
|
message(" ==> : ${LIBRARY_AUTHORS}")
|
|
endif()
|
|
if (LIBRARY_VERSION)
|
|
message("LIBRARY_VERSION : ${LIBRARY_VERSION}")
|
|
GLD_load_from_file_if_needed(LIBRARY_VERSION "${MODULE_MAP_${LOCAL_MODULE_NAME}_FOLDER}" "${LIBRARY_VERSION}")
|
|
message(" ==> : ${LIBRARY_VERSION}")
|
|
# NOTE CMAKE does not support DEV_MODEL, then we use the lact ELEMENT for dev version (666)
|
|
string(REPLACE "-dev" ".666" LIBRARY_VERSION ${LIBRARY_VERSION})
|
|
endif()
|
|
|
|
#string(REPLACE "-" "_" LIBRARY_NAME222 ${NAME_GLD_MODULE})
|
|
set(LIBRARY_NAME222 ${NAME_GLD_MODULE})
|
|
if (LIBRARY_VERSION)
|
|
project(${LIBRARY_NAME222} VERSION ${LIBRARY_VERSION})
|
|
set(${LIBRARY_NAME222} PROPERTIES CPACK_PACKAGE_VERSION ${LIBRARY_VERSION})
|
|
else()
|
|
project(${LIBRARY_NAME222})
|
|
endif()
|
|
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_INCLUDE_LOCAL "" CACHE INTERNAL "")
|
|
|
|
# TODO : Remove if no element in header...
|
|
if (MODULE_MAP_${LOCAL_MODULE_NAME}_HEADER)
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_INCLUDE_PUBLIC "${GLD_GLOBAL_BUILD_FOLDER}${NAME_GLD_MODULE}/include/" CACHE INTERNAL "")
|
|
endif()
|
|
# remove if no library generated
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_LIB_PATH "${GLD_GLOBAL_STAGING_FOLDER}${NAME_GLD_MODULE}/lib/" CACHE INTERNAL "")
|
|
# remove if no doc ...
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_DOC_PATH "${GLD_GLOBAL_STAGING_FOLDER}${NAME_GLD_MODULE}/doc/" CACHE INTERNAL "")
|
|
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY "" CACHE INTERNAL "")
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_SOURCE "" CACHE INTERNAL "")
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_HEADER "" CACHE INTERNAL "")
|
|
|
|
GLD_import_full(${NAME_GLD_MODULE} ${MY_JSON_STRING})
|
|
set(TMP_LIST "")
|
|
foreach(III ${MODULE_MAP_${LOCAL_MODULE_NAME}_INCLUDE_LOCAL})
|
|
get_filename_component(BASE_FOLDER ${MODULE_MAP_${LOCAL_MODULE_NAME}_FOLDER}/${III} ABSOLUTE)
|
|
list(APPEND TMP_LIST "${BASE_FOLDER}")
|
|
endforeach()
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_INCLUDE_LOCAL "${TMP_LIST}" CACHE INTERNAL "")
|
|
|
|
message(" _INCLUDE_LOCAL : ${MODULE_MAP_${LOCAL_MODULE_NAME}_INCLUDE_LOCAL}")
|
|
message(" _INCLUDE_PUBLIC: ${MODULE_MAP_${LOCAL_MODULE_NAME}_INCLUDE_PUBLIC}")
|
|
message(" _LIB_PATH : ${MODULE_MAP_${LOCAL_MODULE_NAME}_LIB_PATH}")
|
|
message(" _DOC_PATH : ${MODULE_MAP_${LOCAL_MODULE_NAME}_DOC_PATH}")
|
|
message(" _DEPENDENCY : ${MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY}")
|
|
message(" _SOURCE : ${MODULE_MAP_${LOCAL_MODULE_NAME}_SOURCE}")
|
|
message(" _HEADER : ${MODULE_MAP_${LOCAL_MODULE_NAME}_HEADER}")
|
|
|
|
set(TMP_LIST "")
|
|
foreach(III ${MODULE_MAP_${LOCAL_MODULE_NAME}_SOURCE})
|
|
get_filename_component(BASE_FOLDER ${MODULE_MAP_${LOCAL_MODULE_NAME}_FOLDER}/${III} ABSOLUTE)
|
|
list(APPEND TMP_LIST "${BASE_FOLDER}")
|
|
endforeach()
|
|
add_library(${LIBRARY_NAME222}_OBJ OBJECT ${TMP_LIST})
|
|
# allow relocation code for shared library:
|
|
set_property(TARGET ${LIBRARY_NAME222}_OBJ PROPERTY POSITION_INDEPENDENT_CODE 1)
|
|
|
|
|
|
foreach(III ${MODULE_MAP_${LOCAL_MODULE_NAME}_HEADER})
|
|
configure_file(${MODULE_MAP_${LOCAL_MODULE_NAME}_FOLDER}/${III} ${MODULE_MAP_${LOCAL_MODULE_NAME}_INCLUDE_PUBLIC}/${III} COPYONLY)
|
|
endforeach()
|
|
|
|
set(TMP_LIST ${MODULE_MAP_${LOCAL_MODULE_NAME}_INCLUDE_LOCAL})
|
|
list(APPEND TMP_LIST ${MODULE_MAP_${LOCAL_MODULE_NAME}_INCLUDE_PUBLIC})
|
|
target_include_directories(${LIBRARY_NAME222}_OBJ PUBLIC "${TMP_LIST}")
|
|
add_library(${LIBRARY_NAME222}_dynamic SHARED $<TARGET_OBJECTS:${LIBRARY_NAME222}_OBJ>)
|
|
add_library(${LIBRARY_NAME222}_static STATIC $<TARGET_OBJECTS:${LIBRARY_NAME222}_OBJ>)
|
|
|
|
if ("${GLD_TARGET}" STREQUAL "Windows")
|
|
set_target_properties(${LIBRARY_NAME222}_dynamic PROPERTIES OUTPUT_NAME ${LIBRARY_NAME222})
|
|
# static will keep the element static at the end (the windows architecture fore shared object need to have a static library to access to the DLL ==> create a conflict!!!
|
|
else()
|
|
set_target_properties(${LIBRARY_NAME222}_dynamic PROPERTIES OUTPUT_NAME ${LIBRARY_NAME222})
|
|
set_target_properties(${LIBRARY_NAME222}_static PROPERTIES OUTPUT_NAME ${LIBRARY_NAME222})
|
|
endif()
|
|
if (LIBRARY_VERSION)
|
|
set_target_properties(${LIBRARY_NAME222}_dynamic PROPERTIES VERSION ${LIBRARY_VERSION})
|
|
set_target_properties(${LIBRARY_NAME222}_dynamic PROPERTIES SOVERSION ${LIBRARY_VERSION})
|
|
endif()
|
|
if (LIBRARY_DECRIPTION)
|
|
set_target_properties(${LIBRARY_NAME222}_dynamic PROPERTIES DESCRIPTION ${LIBRARY_DECRIPTION})
|
|
endif()
|
|
|
|
# install dynamic & static library
|
|
install(TARGETS ${LIBRARY_NAME222}_dynamic EXPORT ${LIBRARY_NAME222}Targets
|
|
RUNTIME DESTINATION ${MODULE_MAP_${LOCAL_MODULE_NAME}_LIB_PATH}
|
|
)
|
|
install(TARGETS ${LIBRARY_NAME222}_static
|
|
RUNTIME DESTINATION ${MODULE_MAP_${LOCAL_MODULE_NAME}_LIB_PATH})
|
|
|
|
|
|
#install(TARGETS ${LIBRARY_NAME222} EXPORT ${LIBRARY_NAME222}Targets
|
|
# LIBRARY DESTINATION lib
|
|
# ARCHIVE DESTINATION lib
|
|
# RUNTIME DESTINATION bin
|
|
# INCLUDES DESTINATION include
|
|
#)
|
|
# install exported headers
|
|
# this copy all the headers in a single folder:
|
|
#install(FILES ${EXPORT_HEADER_LIST} DESTINATION include)
|
|
# this keep the basic path for each folders:
|
|
set(BASE "${PROJECT_SOURCE_DIR}/install")
|
|
foreach(ITEM ${EXPORT_HEADER_LIST})
|
|
get_filename_component(ITEM_PATH ${ITEM} PATH)
|
|
string(REPLACE ${BASE} "" ITEM_PATH ${ITEM_PATH})
|
|
install(FILES ${ITEM}
|
|
DESTINATION "include/${ITEM_PATH}"
|
|
COMPONENT Devel)
|
|
endforeach()
|
|
|
|
|
|
|
|
|
|
include(CMakePackageConfigHelpers)
|
|
#write_basic_package_version_file(
|
|
# "${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME222}/${LIBRARY_NAME222}ConfigVersion.cmake"
|
|
# VERSION ${LIBRARY_VERSION}
|
|
# COMPATIBILITY AnyNewerVersion
|
|
#)
|
|
#
|
|
#export(EXPORT ${LIBRARY_NAME222}Targets
|
|
# FILE "${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME222}/${LIBRARY_NAME222}Targets.cmake"
|
|
# NAMESPACE Upstream::
|
|
#)
|
|
##configure_file(cmake/${LIBRARY_NAME222}Config.cmake
|
|
## "${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME222}/${LIBRARY_NAME222}Config.cmake"
|
|
## COPYONLY
|
|
##)
|
|
|
|
set(CONFIG_PACKAGE_LOCATION cmake/${LIBRARY_NAME222})
|
|
install(EXPORT ${LIBRARY_NAME222}Targets
|
|
FILE
|
|
${LIBRARY_NAME222}Targets.cmake
|
|
NAMESPACE
|
|
${LIBRARY_NAME222}::
|
|
DESTINATION
|
|
${CONFIG_PACKAGE_LOCATION}
|
|
)
|
|
#install(
|
|
# FILES
|
|
# cmake/${LIBRARY_NAME222}Config.cmake
|
|
# "${CMAKE_CURRENT_BINARY_DIR}/${LIBRARY_NAME222}/${LIBRARY_NAME222}ConfigVersion.cmake"
|
|
# DESTINATION
|
|
# ${CONFIG_PACKAGE_LOCATION}
|
|
# COMPONENT
|
|
# Devel
|
|
#)
|
|
message("CMAKE_INSTALL_LIBDIR===${CMAKE_INSTALL_LIBDIR}")
|
|
|
|
|
|
endfunction()
|
|
|
|
|
|
function(sdfsqdfqsdfqrezesrdtygfhsg LIST_OF_MODULE_AVAILLABLE)
|
|
include(CMakePackageConfigHelpers)
|
|
configure_package_config_file(cmake/${LIBRARY_NAME222}Config.cmake.in
|
|
"${PROJECT_BINARY_DIR}/${LIBRARY_NAME222}Config.cmake"
|
|
INSTALL_DESTINATION ${CONFIG_PACKAGE_LOCATION}
|
|
NO_SET_AND_CHECK_MACRO
|
|
NO_CHECK_REQUIRED_COMPONENTS_MACRO)
|
|
write_basic_package_version_file(
|
|
"${PROJECT_BINARY_DIR}/${LIBRARY_NAME222}ConfigVersion.cmake"
|
|
VERSION ${LIBRARY_VERSION}
|
|
COMPATIBILITY SameMajorVersion)
|
|
install(
|
|
FILES
|
|
"${PROJECT_BINARY_DIR}/${LIBRARY_NAME222}Config.cmake"
|
|
"${PROJECT_BINARY_DIR}/${LIBRARY_NAME222}ConfigVersion.cmake"
|
|
DESTINATION ${CONFIG_PACKAGE_LOCATION}
|
|
COMPONENT Devel)
|
|
|
|
|
|
endfunction()
|
|
|
|
|
|
function(GLD_generate_cmake_wrapping LIST_OF_MODULE_AVAILLABLE)
|
|
message("Generate cmake wrapping")
|
|
foreach(NAME_GLD_MODULE ${LIST_OF_MODULE_AVAILLABLE})
|
|
GLD_get_module_name(LOCAL_MODULE_NAME ${NAME_GLD_MODULE})
|
|
message("Import: ${NAME_GLD_MODULE}")
|
|
#MODULE_MAP_LIST_DEPENDENCE_RESOLVED
|
|
GLD_import(${NAME_GLD_MODULE})
|
|
endforeach()
|
|
message("Generate cmake wrapping (DONE)")
|
|
endfunction()
|
|
|
|
|
|
##
|
|
## @brief List all folder in a specific inout folder.
|
|
## @param[out] VAR_OUT Result list of folders.
|
|
## @param[in] BASE_FOLDER Basic folder to parse.
|
|
##
|
|
function(sub_dir_list VAR_OUT BASE_FOLDER)
|
|
#message(" Search: ${BASE_FOLDER}" )
|
|
file(GLOB children "${BASE_FOLDER}/*")
|
|
#message(" ==>>> ${children}" )
|
|
set(dirlist "")
|
|
foreach(child ${children})
|
|
#message(" - ${child}" )
|
|
if(IS_DIRECTORY ${child})
|
|
#message(" ==> is directory" )
|
|
list(APPEND dirlist ${child})
|
|
endif()
|
|
endforeach()
|
|
set(${VAR_OUT} ${dirlist} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
|
|
##
|
|
## @brief Recursive search of a specific patter (stop whan find the pattern in a folder.
|
|
## (have a limit of parsing ==> optimise resarch in a worktree).
|
|
## @param[out] VAR_OUT List of all files that corespond of the reg-exp
|
|
## @param[in] BASE_FOLDER Basic folder to parse.
|
|
## @param[in] REG_EXP Regular expression to search the data.
|
|
## @param[in] LIMIT Lismit of folder to recursively parse.
|
|
##
|
|
function(find_all_files VAR_OUT BASE_FOLDER REG_EXP LIMIT)
|
|
if (${LIMIT} LESS_EQUAL 0)
|
|
set(${VAR_OUT} "" PARENT_SCOPE)
|
|
return()
|
|
endif()
|
|
MATH(EXPR LIMIT "${LIMIT}-1")
|
|
get_filename_component(BASE_FOLDER ${BASE_FOLDER} ABSOLUTE)
|
|
#message("KK Search in subDiratory: ${BASE_FOLDER}/${REG_EXP}" )
|
|
file(GLOB GLD_FILES "${BASE_FOLDER}/${REG_EXP}")
|
|
#message("Find file: '${GLD_FILES}'" )
|
|
if("${GLD_FILES}" STREQUAL "")
|
|
#message("Search in subDiratory: ${BASE_FOLDER}" )
|
|
# no element continue search...
|
|
set(SUBDIRS "")
|
|
sub_dir_list(SUBDIRS "${BASE_FOLDER}")
|
|
#message(" =!=> : ${SUBDIRS}" )
|
|
foreach(ELEM ${SUBDIRS})
|
|
get_filename_component(DIR_NAME_RELATIVE ${ELEM} NAME)
|
|
#message(" =!=> DIR_NAME_RELATIVE = ${DIR_NAME_RELATIVE}" )
|
|
if("${DIR_NAME_RELATIVE}" STREQUAL ".git" OR "${DIR_NAME_RELATIVE}" STREQUAL ".island" OR "${DIR_NAME_RELATIVE}" STREQUAL "archive" OR "${DIR_NAME_RELATIVE}" STREQUAL "out" OR "${DIR_NAME_RELATIVE}" STREQUAL "target")
|
|
continue()
|
|
endif()
|
|
if("${ELEM}" STREQUAL "${BASE_FOLDER}" OR "${ELEM}" STREQUAL "${BASE_FOLDER}/")
|
|
continue()
|
|
endif()
|
|
#message(" element: ${ELEM}" )
|
|
#message(" BASE_FOLDER: ${BASE_FOLDER}" )
|
|
find_all_files(OUT_SUB_LIST "${ELEM}" "${REG_EXP}" ${LIMIT})
|
|
list(APPEND GLD_FILES ${OUT_SUB_LIST})
|
|
endforeach()
|
|
endif()
|
|
set(${VAR_OUT} ${GLD_FILES} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
|
|
function(GLD_get_full_dependency_group VAR_OUT VAR_OPTIONAL_OUT MY_JSON_STRING ELEMENT_TO_CHECK TYPE_VARIABLE)
|
|
set(LIST_VALUE "")
|
|
set(LIST_OPTIONAL_VALUE "")
|
|
json_get_type(TYPE ${MY_JSON_STRING} ${ELEMENT_TO_CHECK})
|
|
#message("target type = ${TYPE}")
|
|
if (${TYPE} STREQUAL "OBJECT")
|
|
json_object_keys(LIST_KEY ${MY_JSON_STRING} ${ELEMENT_TO_CHECK})
|
|
foreach (III ${LIST_KEY})
|
|
# check the target, no need to had unknown target ...
|
|
if (${III} STREQUAL "*")
|
|
json_object_values(DATA_TARGET ${MY_JSON_STRING} ${ELEMENT_TO_CHECK} "*")
|
|
#message("target(*) data: ${DATA_TARGET}")
|
|
GLD_get_full_dependency(VAR_OUT_TMP LIST_OPTIONAL_VALUE_TMP DATA_TARGET)
|
|
list(APPEND LIST_VALUE ${DATA_TARGET})
|
|
list(APPEND LIST_OPTIONAL_VALUE ${LIST_OPTIONAL_VALUE_TMP})
|
|
elseif (${III} STREQUAL ${TYPE_VARIABLE})
|
|
json_object_values(DATA_TARGET ${MY_JSON_STRING} ${ELEMENT_TO_CHECK} "${III}")
|
|
GLD_get_full_dependency(VAR_OUT_TMP LIST_OPTIONAL_VALUE_TMP DATA_TARGET)
|
|
#message("target(${III}) data: ${DATA_TARGET}")
|
|
list(APPEND LIST_VALUE ${VAR_OUT_TMP})
|
|
list(APPEND LIST_OPTIONAL_VALUE ${LIST_OPTIONAL_VALUE_TMP})
|
|
else()
|
|
message("TODO: get dependency manage '${ELEMENT_TO_CHECK}' : ${III}")
|
|
endif()
|
|
endforeach()
|
|
elseif(${TYPE} STREQUAL "NOTFOUND" OR ${TYPE} STREQUAL "NULL")
|
|
# nothing to do ..
|
|
else()
|
|
message("ERROR : '${ELEMENT_TO_CHECK}' can not be other than an json object : ${TYPE}")
|
|
endif()
|
|
set(${VAR_OUT} ${LIST_VALUE} PARENT_SCOPE)
|
|
set(${VAR_OPTIONAL_OUT} ${LIST_OPTIONAL_VALUE} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
|
|
##
|
|
## @brief Get the list of all dependency even if they are optional.
|
|
## @param[out] VAR_OUT list of dependency library
|
|
## @param[out] VAR_OPTIONAL_OUT list of optional dependency library
|
|
## @param[in] MY_JSON_STRING Json string
|
|
## @note This function is dependent of the target
|
|
##
|
|
function(GLD_get_full_dependency VAR_OUT VAR_OPTIONAL_OUT MY_JSON_STRING)
|
|
json_get_type(TYPE ${MY_JSON_STRING} "dependency")
|
|
set(LIST_VALUE "")
|
|
set(LIST_OPTIONAL_VALUE "")
|
|
#message("Dependency type = ${TYPE}")
|
|
if (${TYPE} STREQUAL "ARRAY")
|
|
json_size(SIZE ${MY_JSON_STRING} "dependency")
|
|
#message("Dependency SIZE = ${SIZE}")
|
|
json_get_data(OBJECT_DATA ${MY_JSON_STRING} "dependency")
|
|
MATH(EXPR SIZE "${SIZE}-1")
|
|
set(VAR_OUT_TMP "")
|
|
foreach(IDX RANGE ${SIZE})
|
|
json_get_data(ELEMENT ${OBJECT_DATA} ${IDX})
|
|
json_get_type(TYPE ${OBJECT_DATA} ${IDX})
|
|
if (${TYPE} STREQUAL "STRING")
|
|
message(" - : ${ELEMENT}")
|
|
list(APPEND VAR_OUT_TMP ${ELEMENT})
|
|
elseif (${TYPE} STREQUAL "OBJECT")
|
|
json_get_type(TYPE ${ELEMENT} "name")
|
|
if (${TYPE} STREQUAL "STRING")
|
|
json_get_data(DEPENDENCY_NAME ${ELEMENT} "name")
|
|
json_get_type(TYPE ${ELEMENT} "optional")
|
|
#message("optional type = ${TYPE} <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ${DEPENDENCY_NAME}")
|
|
if (${TYPE} STREQUAL "BOOLEAN")
|
|
json_get_data(DEPENDENCY_OPTIONAL ${ELEMENT} "optional")
|
|
if (${DEPENDENCY_OPTIONAL})
|
|
message(" - : ${DEPENDENCY_NAME} (optional)")
|
|
#message("optional value ==========================> '${DEPENDENCY_OPTIONAL}' ==> MAYBE")
|
|
list(APPEND LIST_OPTIONAL_VALUE ${DEPENDENCY_NAME})
|
|
else()
|
|
message(" - : ${DEPENDENCY_NAME}")
|
|
#message("optional value ==========================> '${DEPENDENCY_OPTIONAL}' ==> MUST")
|
|
list(APPEND VAR_OUT_TMP ${DEPENDENCY_NAME})
|
|
endif()
|
|
else()
|
|
message(" - : ${DEPENDENCY_NAME}")
|
|
list(APPEND VAR_OUT_TMP ${DEPENDENCY_NAME})
|
|
endif()
|
|
#message("optional type = ${TYPE} <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ${DEPENDENCY_NAME}")
|
|
else()
|
|
message("Dependency 'name' is not a string or is missing type: ${TYPE}")
|
|
endif()
|
|
else()
|
|
message("dependency element not manage data : ${ELEMENT}")
|
|
## TODO add in dependency if optional : check if the element exit in the current module list ...
|
|
|
|
endif()
|
|
endforeach()
|
|
list(APPEND LIST_VALUE ${VAR_OUT_TMP})
|
|
endif()
|
|
|
|
GLD_get_full_dependency_group(VAR_OUT_TMP LIST_OPTIONAL_VALUE_TMP MY_JSON_STRING "target" ${GLD_TARGET})
|
|
list(APPEND LIST_VALUE ${VAR_OUT_TMP})
|
|
list(APPEND LIST_OPTIONAL_VALUE ${LIST_OPTIONAL_VALUE_TMP})
|
|
|
|
GLD_get_full_dependency_group(VAR_OUT_TMP LIST_OPTIONAL_VALUE_TMP MY_JSON_STRING "mode" ${GLD_MODE})
|
|
list(APPEND LIST_VALUE ${VAR_OUT_TMP})
|
|
list(APPEND LIST_OPTIONAL_VALUE ${LIST_OPTIONAL_VALUE_TMP})
|
|
|
|
GLD_get_full_dependency_group(VAR_OUT_TMP LIST_OPTIONAL_VALUE_TMP MY_JSON_STRING "arch" ${GLD_ARCH})
|
|
list(APPEND LIST_VALUE ${VAR_OUT_TMP})
|
|
list(APPEND LIST_OPTIONAL_VALUE ${LIST_OPTIONAL_VALUE_TMP})
|
|
|
|
GLD_get_full_dependency_group(VAR_OUT_TMP LIST_OPTIONAL_VALUE_TMP MY_JSON_STRING "bus-size" ${GLD_BUS_SIZE})
|
|
list(APPEND LIST_VALUE ${VAR_OUT_TMP})
|
|
list(APPEND LIST_OPTIONAL_VALUE ${LIST_OPTIONAL_VALUE_TMP})
|
|
|
|
GLD_get_full_dependency_group(VAR_OUT_TMP LIST_OPTIONAL_VALUE_TMP MY_JSON_STRING "compilator" ${GLD_COMPILATOR})
|
|
list(APPEND LIST_VALUE ${VAR_OUT_TMP})
|
|
list(APPEND LIST_OPTIONAL_VALUE ${LIST_OPTIONAL_VALUE_TMP})
|
|
|
|
GLD_get_full_dependency_group(VAR_OUT_TMP LIST_OPTIONAL_VALUE_TMP MY_JSON_STRING "sanity-compilation" ${GLD_SANITY_MODE})
|
|
list(APPEND LIST_VALUE ${VAR_OUT_TMP})
|
|
list(APPEND LIST_OPTIONAL_VALUE ${LIST_OPTIONAL_VALUE_TMP})
|
|
|
|
set(${VAR_OUT} ${LIST_VALUE} PARENT_SCOPE)
|
|
set(${VAR_OPTIONAL_OUT} ${LIST_OPTIONAL_VALUE} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
|
|
function(GLD_read_json_file VAR_OUT JSON_FILE)
|
|
file(READ ${JSON_FILE} MY_JSON_STRING)
|
|
if("${MY_JSON_STRING}" STREQUAL "")
|
|
message(WARNING "Empty json file : '${JSON_FILE}'")
|
|
else()
|
|
string(REPLACE " " "" MY_JSON_STRING ${MY_JSON_STRING})
|
|
string(REPLACE "\t" "" MY_JSON_STRING ${MY_JSON_STRING})
|
|
string(REPLACE "\n" "" MY_JSON_STRING ${MY_JSON_STRING})
|
|
endif()
|
|
set(${VAR_OUT} ${MY_JSON_STRING} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
|
|
|
|
set(MODULE_MAP_LIST "" CACHE INTERNAL "")
|
|
set(MODULE_MAP_LIST_DEPENDENCE_RESOLVED "" CACHE INTERNAL "")
|
|
|
|
function(GLD_get_module_name VAR_OUT BASE_NAME)
|
|
string(REPLACE "_" "_U_" TMP ${BASE_NAME})
|
|
string(REPLACE "." "_D_" TMP ${BASE_NAME})
|
|
string(REPLACE "-" "_S_" TMP ${TMP})
|
|
set(${VAR_OUT} ${TMP} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
function(GLD_add_module NAME_GLD_MODULE FOLDER FILENAME)
|
|
GLD_get_module_name(LOCAL_MODULE_NAME ${NAME_GLD_MODULE})
|
|
message("Add module: ${LOCAL_MODULE_NAME} ==> ${NAME_GLD_MODULE} in ${FILENAME}")
|
|
|
|
# load all the json data:
|
|
GLD_read_json_file(JSON_DATA "${FOLDER}/${FILENAME}.json")
|
|
if("${JSON_DATA}" STREQUAL "")
|
|
message(WARNING "SKIP library: ${NAME_GLD_MODULE}")
|
|
else()
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_FOLDER ${FOLDER} CACHE INTERNAL "")
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_FILENAME ${FILENAME} CACHE INTERNAL "")
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_NAME ${NAME_GLD_MODULE} CACHE INTERNAL "")
|
|
set(MODULE_MAP_LIST ${MODULE_MAP_LIST} ${NAME_GLD_MODULE} CACHE INTERNAL "")
|
|
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_JSON "${JSON_DATA}" CACHE INTERNAL "")
|
|
endif()
|
|
endfunction()
|
|
|
|
function(GLD_generate_module_without_optionnal_inexistant NAME_GLD_MODULE)
|
|
GLD_get_module_name(LOCAL_MODULE_NAME ${NAME_GLD_MODULE})
|
|
#message("Call : GLD_get_full_dependency(outA, outB, ${MODULE_MAP_${LOCAL_MODULE_NAME}_JSON}) ${NAME_GLD_MODULE} ==> ${LOCAL_MODULE_NAME}")
|
|
GLD_get_full_dependency(DEPENDENCY DEPENDENCY_OPTIONAL ${MODULE_MAP_${LOCAL_MODULE_NAME}_JSON})
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY ${DEPENDENCY} CACHE INTERNAL "")
|
|
set(MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY_OPTIONAL ${DEPENDENCY_OPTIONAL} CACHE INTERNAL "")
|
|
endfunction()
|
|
|
|
|
|
|
|
function(GLD_is_in_list VAR_OUT ELEM_TO_CHECK LIST_TO_CHECK)
|
|
set(ELEMENT_FIND "true")
|
|
#message(" verify '${ELEM_TO_CHECK}' in '${LIST_TO_CHECK}'")
|
|
foreach(ELEM ${LIST_TO_CHECK})
|
|
if ("${ELEM_TO_CHECK}" STREQUAL "${ELEM}")
|
|
set(${VAR_OUT} "true" PARENT_SCOPE)
|
|
#message(" ==> true")
|
|
return()
|
|
endif()
|
|
endforeach()
|
|
set(${VAR_OUT} "false" PARENT_SCOPE)
|
|
#message(" ==> false")
|
|
endfunction()
|
|
|
|
function(GLD_are_in_list VAR_OUT LIST_VALUES LIST_TO_CHECK)
|
|
set(ELEMENT_FIND "true")
|
|
#message(" verify '${LIST_VALUES}' are in '${LIST_TO_CHECK}'")
|
|
foreach(ELEM ${LIST_VALUES})
|
|
GLD_is_in_list(EXIST "${ELEM}" "${LIST_TO_CHECK}")
|
|
if (${EXIST} STREQUAL "false")
|
|
set(${VAR_OUT} "false" PARENT_SCOPE)
|
|
#message(" =>> false")
|
|
return()
|
|
endif()
|
|
endforeach()
|
|
set(${VAR_OUT} "true" PARENT_SCOPE)
|
|
#message(" =>> true")
|
|
endfunction()
|
|
|
|
## todo: REMOVE OPTIONNAL DEPENDENCY THAT DOES NOT EXIST IN THE LIST
|
|
## TODO: display and does not include element that dependency are not resolved and indicate which dependency is not found ...
|
|
function(GLD_order_dependency_list VAR_OUT DEPENDENCY_FAILED)
|
|
set(TMP_ORDERED "")####### crypto;edtaa3;luaWrapper;freetype;")
|
|
set(TMP_UN_ADDED "")
|
|
message("===========================================")
|
|
message("== STEP 1 : Add all module without dependency:")
|
|
message("===========================================")
|
|
# step 1 Add all module without dependency:
|
|
foreach(MODULE_ELEM ${MODULE_MAP_LIST})
|
|
message("check add element : ${MODULE_ELEM}")
|
|
message(" dependency = '${MODULE_ELEM}'")
|
|
GLD_get_module_name(LOCAL_MODULE_NAME ${MODULE_ELEM})
|
|
message(" dependency = '${MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY}'")
|
|
# todo check dependency here ... ${MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY}
|
|
list(LENGTH MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY LIST_LENGTH)
|
|
message(" ==> length'${LIST_LENGTH}'")
|
|
if (LIST_LENGTH EQUAL 0)
|
|
message("Add element ${III} (0 dependency) ******** ")
|
|
list(APPEND TMP_ORDERED ${MODULE_ELEM})
|
|
continue()
|
|
endif()
|
|
list(APPEND TMP_UN_ADDED ${MODULE_ELEM})
|
|
endforeach()
|
|
message("result: ${TMP_ORDERED}")
|
|
message("===========================================")
|
|
message("== STEP 2 : Add all when the dependency are available in the list:")
|
|
message("===========================================")
|
|
# step 2 Add all when the dependency are available in the list:
|
|
list(LENGTH TMP_UN_ADDED LIST_TOTAL_LENGTH)
|
|
message("unadded : ${LIST_TOTAL_LENGTH}")
|
|
# must be resolved in the number of cycle in the list (maximum)
|
|
foreach(III RANGE ${LIST_TOTAL_LENGTH})
|
|
message("cycle : ${III}")
|
|
set(TMP_UN_ADDED_TMP ${TMP_UN_ADDED})
|
|
set(TMP_UN_ADDED "")
|
|
foreach(ELEM_TO_ADD ${TMP_UN_ADDED_TMP})
|
|
message(" check to add : ${ELEM_TO_ADD}")
|
|
GLD_get_module_name(LOCAL_MODULE_NAME ${ELEM_TO_ADD})
|
|
message(" dependency : ${MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY} in ? ${TMP_ORDERED}")
|
|
GLD_are_in_list(IS_ALL_PRESENT "${MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY}" "${TMP_ORDERED}")
|
|
if (${IS_ALL_PRESENT} STREQUAL "true")
|
|
message("Add element ${ELEM_TO_ADD} (depend: ${MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY})")
|
|
list(APPEND TMP_ORDERED ${ELEM_TO_ADD})
|
|
else()
|
|
list(APPEND TMP_UN_ADDED ${ELEM_TO_ADD})
|
|
endif()
|
|
endforeach()
|
|
endforeach()
|
|
message("result:")
|
|
foreach(ELEM ${TMP_ORDERED})
|
|
message(" - ${ELEM}")
|
|
endforeach()
|
|
message("===========================================")
|
|
message("== STEP 3 : All must be added before...")
|
|
message("===========================================")
|
|
# step 3 All must be added before...
|
|
list(LENGTH TMP_UN_ADDED LIST_TOTAL_LENGTH)
|
|
if (${LIST_TOTAL_LENGTH} GREATER_EQUAL 0)
|
|
message(WARNING "Some element are not added: (${LIST_TOTAL_LENGTH})")
|
|
foreach(ELEM ${TMP_UN_ADDED})
|
|
message(" - ${ELEM}")
|
|
GLD_get_module_name(LOCAL_MODULE_NAME ${ELEM})
|
|
message(" dep : ${MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY}")
|
|
message(" dep(optional): ${MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY_OPTIONAL}")
|
|
endforeach()
|
|
endif()
|
|
set(MODULE_MAP_LIST_DEPENDENCE_RESOLVED ${TMP_ORDERED} CACHE INTERNAL "")
|
|
set(${VAR_OUT} ${TMP_ORDERED} PARENT_SCOPE)
|
|
set(${DEPENDENCY_FAILED} ${TMP_UN_ADDED} PARENT_SCOPE)
|
|
endfunction()
|
|
|
|
|
|
function(GLD_load_all ROOT_FOLDER BASE_NAME COMMENT_ACTION)
|
|
message("Parse all files ${BASE_NAME}*.json: base: ${ROOT_FOLDER}")
|
|
#file(GLOB_RECURSE GLD_FILES "${ROOT_FOLDER}/GLD_*.json")
|
|
find_all_files(GLD_FILES "${ROOT_FOLDER}" "${BASE_NAME}*.json" 5)
|
|
message("List of GLD files:")
|
|
foreach(III ${GLD_FILES})
|
|
GET_FILENAME_COMPONENT(FILENAME ${III} NAME_WE)
|
|
set(FULL_FILENAME ${FILENAME})
|
|
string(REPLACE "${BASE_NAME}" "" FILENAME ${FILENAME})
|
|
GET_FILENAME_COMPONENT(FOLDER ${III} DIRECTORY)
|
|
message(" - ${COMMENT_ACTION} ${FOLDER} ==> ${FILENAME}")
|
|
GLD_add_module(${FILENAME} ${FOLDER} ${FULL_FILENAME})
|
|
endforeach()
|
|
#GLD_import("./" "etk-core")
|
|
endfunction()
|
|
|
|
function(GLD_auto_prebuild_load_all ROOT_FOLDER)
|
|
GLD_load_all(${ROOT_FOLDER} "GLDPrebuild_${GLD_TARGET}_" "(prebuild)")
|
|
endfunction()
|
|
|
|
function(GLD_auto_load_all ROOT_FOLDER)
|
|
GLD_load_all(${ROOT_FOLDER} "GLD_" "")
|
|
endfunction()
|
|
|
|
|
|
function(GLD_instanciate)
|
|
message("List of modules:")
|
|
foreach(III ${MODULE_MAP_LIST})
|
|
GLD_get_module_name(LOCAL_MODULE_NAME ${III})
|
|
message(" - ${III}")
|
|
endforeach()
|
|
foreach(III ${MODULE_MAP_LIST})
|
|
GLD_get_module_name(LOCAL_MODULE_NAME ${III})
|
|
GLD_generate_module_without_optionnal_inexistant(${III})
|
|
message(" - ${III}")
|
|
message(" FOLDER=${MODULE_MAP_${LOCAL_MODULE_NAME}_FOLDER}")
|
|
#message(" JSON=${MODULE_MAP_${LOCAL_MODULE_NAME}_JSON}")
|
|
message(" DEPENDENCY=${MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY}")
|
|
message(" DEPENDENCY_OPTIONAL=${MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY_OPTIONAL}")
|
|
endforeach()
|
|
GLD_order_dependency_list(DEPENDENCY_ORDER DEPENDENCY_FAILED)
|
|
|
|
GLD_generate_cmake_wrapping("${DEPENDENCY_ORDER}")
|
|
|
|
#message("dependency resolver & ordered:")
|
|
#foreach(III ${DEPENDENCY_ORDER})
|
|
# message(" - ${III}")
|
|
#endforeach()
|
|
|
|
#message("dependency fail:")
|
|
#foreach(III ${DEPENDENCY_FAILED})
|
|
# message(" - ${III}")
|
|
#endforeach()
|
|
|
|
endfunction()
|
|
|