2021-11-07 23:16:09 +01:00
cmake_minimum_required ( VERSION 3.20 )
2021-11-10 23:50:26 +01:00
include ( "cmake/GLDJson.cmake" )
include ( "cmake/GLDTargetConfig.cmake" )
include ( "cmake/GLDTools.cmake" )
2021-11-07 23:16:09 +01:00
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}")
2021-11-10 23:50:26 +01:00
if ( SIZE GREATER 0 )
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 } )
2021-11-07 23:16:09 +01:00
if ( ${ TYPE } STREQUAL "STRING" )
2021-11-10 23:50:26 +01:00
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 ( )
2021-11-07 23:16:09 +01:00
else ( )
message ( " - <dep> : ${DEPENDENCY_NAME}" )
list ( APPEND VAR_OUT_TMP ${ DEPENDENCY_NAME } )
endif ( )
2021-11-10 23:50:26 +01:00
#message("optional type = ${TYPE} <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ${DEPENDENCY_NAME}")
2021-11-07 23:16:09 +01:00
else ( )
2021-11-10 23:50:26 +01:00
message ( "Dependency 'name' is not a string or is missing type: ${TYPE}" )
2021-11-07 23:16:09 +01:00
endif ( )
else ( )
2021-11-10 23:50:26 +01:00
message ( "dependency element not manage data : ${ELEMENT}" )
## TODO add in dependency if optional : check if the element exit in the current module list ...
2021-11-07 23:16:09 +01:00
endif ( )
2021-11-10 23:50:26 +01:00
endforeach ( )
list ( APPEND LIST_VALUE ${ VAR_OUT_TMP } )
endif ( )
2021-11-07 23:16:09 +01:00
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}")
2021-11-10 23:50:26 +01:00
if ( SIZE GREATER 0 )
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 } )
2021-11-07 23:16:09 +01:00
if ( ${ TYPE } STREQUAL "STRING" )
2021-11-10 23:50:26 +01:00
message ( " - <src> : ${ELEMENT}" )
list ( APPEND LIST_VALUE ${ ELEMENT } )
elseif ( ${ TYPE } STREQUAL "OBJECT" )
message ( " - <src2> : ${ELEMENT}" )
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 ...
2021-11-07 23:16:09 +01:00
else ( )
2021-11-10 23:50:26 +01:00
message ( "'source' element not manage data : ${ELEMENT}" )
## TODO add in dependency if optional : check if the element exit in the current module list ...
2021-11-07 23:16:09 +01:00
endif ( )
2021-11-10 23:50:26 +01:00
endforeach ( )
endif ( )
2021-11-07 23:16:09 +01:00
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}")
2021-11-10 23:50:26 +01:00
if ( SIZE GREATER 0 )
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 } )
2021-11-07 23:16:09 +01:00
if ( ${ TYPE } STREQUAL "STRING" )
2021-11-10 23:50:26 +01:00
message ( " - <header> : ${ELEMENT}" )
list ( APPEND LIST_VALUE ${ ELEMENT } )
elseif ( ${ TYPE } STREQUAL "OBJECT" )
json_get_type ( TYPE ${ ELEMENT } "source" )
if ( ${ TYPE } STREQUAL "NOTFOUND" )
json_get_type ( TYPE ${ ELEMENT } "path" )
if ( ${ TYPE } STREQUAL "STRING" )
json_get_data ( ELEMENT_PATH ${ ELEMENT } "path" )
json_get_data_or_default ( ELEMENT_FILTER ${ ELEMENT } "filter" "*" )
json_get_data_or_default ( ELEMENT_RECURSIVE ${ ELEMENT } "path" OFF )
json_get_data_or_default ( ELEMENT_TO ${ ELEMENT } "to" "" )
find_all_files ( ALL_HEADER_FILES "${MODULE_MAP_${LOCAL_MODULE_NAME}_FOLDER}/${ELEMENT_PATH}" "${ELEMENT_FILTER}" 50 )
#message("***********************************************************************")
#foreach(III ${ALL_HEADER_FILES})
# message(" ==> ${III}")
#endforeach()
#message("STATIC_PART = ${MODULE_MAP_${LOCAL_MODULE_NAME}_FOLDER}/${STATIC_PART}")
replace_base_path ( ALL_HEADER_FILES_2 "${MODULE_MAP_${LOCAL_MODULE_NAME}_FOLDER}/${ELEMENT_PATH}" "${ALL_HEADER_FILES}" )
#message("***********************************************************************")
set ( ALL_HEADER_FILES "" )
foreach ( III ${ ALL_HEADER_FILES_2 } )
#message(" ==> ${III}!${ELEMENT_PATH}:${ELEMENT_TO}")
list ( APPEND ALL_HEADER_FILES "${III}!${ELEMENT_PATH}:${ELEMENT_TO}" )
endforeach ( )
list ( APPEND LIST_VALUE ${ ALL_HEADER_FILES } )
else ( )
message ( "Dependency 'path' is not a string or is missing type: ${TYPE} : STRING ..." )
endif ( )
else ( )
if ( ${ TYPE } STREQUAL "STRING" )
json_get_data ( ELEMENT_SOURCE ${ ELEMENT } "source" )
message ( " - <header> : ${ELEMENT_SOURCE}" )
list ( APPEND LIST_VALUE ${ ELEMENT_SOURCE } )
#message("optional type = ${TYPE} <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< ${DEPENDENCY_NAME}")
elseif ( ${ TYPE } STREQUAL "ARRAY" )
json_get_data ( ELEMENT_SOURCE ${ ELEMENT } "source" )
message ( " - <header> : ${ELEMENT_SOURCE}" )
list ( APPEND LIST_VALUE ${ ELEMENT_SOURCE } )
else ( )
message ( "Dependency 'source' is not a string or is missing type: ${TYPE} : STRING or ARRAY ..." )
endif ( )
endif ( )
# TODO: add the source specific flags or other things ...
2021-11-07 23:16:09 +01:00
else ( )
2021-11-10 23:50:26 +01:00
message ( "'header' element not manage data : ${ELEMENT}" )
## TODO add in dependency if optional : check if the element exit in the current module list ...
2021-11-07 23:16:09 +01:00
endif ( )
2021-11-10 23:50:26 +01:00
endforeach ( )
endif ( )
2021-11-07 23:16:09 +01:00
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 } )
2021-11-10 23:50:26 +01:00
GLD_import_full_group ( ${ NAME_GLD_MODULE } ${ MY_JSON_STRING } "compiler" ${ GLD_COMPILER } )
2021-11-07 23:16:09 +01:00
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 ( )
2021-11-10 23:50:26 +01:00
function ( GLD_get_import_folder VAR_OUT NAME_GLD_MODULE )
set ( LIST_OUT "" )
set ( ${ VAR_OUT } "${LIST_OUT}" PARENT_SCOPE )
endfunction ( )
function ( GLD_get_import_folder VAR_OUT NAME_GLD_MODULE )
set ( LIST_OUT "" )
set ( ${ VAR_OUT } "${LIST_OUT}" PARENT_SCOPE )
endfunction ( )
function ( GLD_get_project_dependency VAR_OUT NAME_GLD_MODULE DEPENDENCY )
GLD_get_module_name ( LOCAL_MODULE_NAME ${ NAME_GLD_MODULE } )
set ( LIST_OUT "" )
if ( DEPENDENCY )
foreach ( III "${DEPENDENCY}" )
GLD_get_module_name ( TMP_MODULE_NAME ${ III } )
list ( APPEND LIST_OUT ${ III } )
endforeach ( )
endif ( )
set ( ${ VAR_OUT } "${LIST_OUT}" PARENT_SCOPE )
endfunction ( )
2021-11-07 23:16:09 +01:00
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 ( )
2021-11-10 23:50:26 +01:00
2021-11-07 23:16:09 +01:00
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}" )
2021-11-10 23:50:26 +01:00
GLD_get_project_dependency ( LIST_PROJECT_DEPENDENCY ${ NAME_GLD_MODULE } "${MODULE_MAP_${LOCAL_MODULE_NAME}_DEPENDENCY}" )
message ( "===> dep = ${LIST_PROJECT_DEPENDENCY}" )
2021-11-07 23:16:09 +01:00
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 ( )
2021-11-10 23:50:26 +01:00
set ( HAS_DATA_TO_BUILD OFF )
if ( TMP_LIST )
set ( HAS_DATA_TO_BUILD ON )
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 )
2021-11-07 23:16:09 +01:00
endif ( )
2021-11-10 23:50:26 +01:00
foreach ( III ${ MODULE_MAP_${LOCAL_MODULE_NAME } _HEADER} )
copy_file_with_reference ( ${ MODULE_MAP_${LOCAL_MODULE_NAME } _FOLDER} ${ III } ${ MODULE_MAP_${LOCAL_MODULE_NAME } _INCLUDE_PUBLIC} )
2021-11-07 23:16:09 +01:00
endforeach ( )
2021-11-10 23:50:26 +01:00
if ( HAS_DATA_TO_BUILD )
set ( TMP_LIST ${ MODULE_MAP_${LOCAL_MODULE_NAME } _INCLUDE_LOCAL} )
list ( APPEND TMP_LIST ${ MODULE_MAP_${LOCAL_MODULE_NAME } _INCLUDE_PUBLIC} )
if ( TMP_LIST )
target_include_directories ( ${ LIBRARY_NAME222 } _OBJ PUBLIC "${TMP_LIST}" )
endif ( )
add_library ( ${ LIBRARY_NAME222 } _dynamic SHARED $< TARGET_OBJECTS:${LIBRARY_NAME222}_OBJ > )
add_library ( ${ LIBRARY_NAME222 } _static STATIC $< TARGET_OBJECTS:${LIBRARY_NAME222}_OBJ > )
if ( LIST_PROJECT_DEPENDENCY )
foreach ( III ${ LIST_PROJECT_DEPENDENCY } )
message ( ">>>>>>>> ${III}" )
add_dependencies ( ${ LIBRARY_NAME222 } _dynamic "${III}_dynamic" )
add_dependencies ( ${ LIBRARY_NAME222 } _static "${III}_static" )
endforeach ( )
endif ( )
2021-11-07 23:16:09 +01:00
2021-11-10 23:50:26 +01:00
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
R U N T I M E D E S T I N A T I O N $ { M O D U L E _ M A P _ $ { L O C A L _ M O D U L E _ N A M E } _ L I B _ P A T H }
)
install ( TARGETS ${ LIBRARY_NAME222 } _static
R U N T I M E D E S T I N A T I O N $ { M O D U L E _ M A P _ $ { L O C A L _ M O D U L E _ N A M E } _ L I B _ P A T H } )
#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 }
D E S T I N A T I O N " i n c l u d e / $ { I T E M _ P A T H } "
C O M P O N E N T D e v e l )
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
F I L E
$ { L I B R A R Y _ N A M E 2 2 2 } T a r g e t s . c m a k e
N A M E S P A C E
$ { L I B R A R Y _ N A M E 2 2 2 } : :
D E S T I N A T I O N
$ { C O N F I G _ P A C K A G E _ L O C A T I O N }
)
endif ( )
2021-11-07 23:16:09 +01:00
#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
" $ { P R O J E C T _ B I N A R Y _ D I R } / $ { L I B R A R Y _ N A M E 2 2 2 } C o n f i g . c m a k e "
I N S T A L L _ D E S T I N A T I O N $ { C O N F I G _ P A C K A G E _ L O C A T I O N }
N O _ S E T _ A N D _ C H E C K _ M A C R O
N O _ C H E C K _ R E Q U I R E D _ C O M P O N E N T S _ M A C R O )
write_basic_package_version_file (
" $ { P R O J E C T _ B I N A R Y _ D I R } / $ { L I B R A R Y _ N A M E 2 2 2 } C o n f i g V e r s i o n . c m a k e "
V E R S I O N $ { L I B R A R Y _ V E R S I O N }
C O M P A T I B I L I T Y S a m e M a j o r V e r s i o n )
install (
F I L E S
" $ { P R O J E C T _ B I N A R Y _ D I R } / $ { L I B R A R Y _ N A M E 2 2 2 } C o n f i g . c m a k e "
" $ { P R O J E C T _ B I N A R Y _ D I R } / $ { L I B R A R Y _ N A M E 2 2 2 } C o n f i g V e r s i o n . c m a k e "
D E S T I N A T I O N $ { C O N F I G _ P A C K A G E _ L O C A T I O N }
C O M P O N E N T D e v e l )
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 ( )
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 } )
2021-11-10 23:50:26 +01:00
GLD_get_full_dependency_group ( VAR_OUT_TMP LIST_OPTIONAL_VALUE_TMP MY_JSON_STRING "compiler" ${ GLD_COMPILER } )
2021-11-07 23:16:09 +01:00
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")
2021-11-10 23:50:26 +01:00
find_all_files_exeption ( GLD_FILES "${ROOT_FOLDER}" "${BASE_NAME}*.json" 5 )
2021-11-07 23:16:09 +01:00
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 ( )
