| # |
| # |
| # Licensed to the Apache Software Foundation (ASF) under one or more |
| # contributor license agreements. See the NOTICE file distributed with |
| # this work for additional information regarding copyright ownership. |
| # The ASF licenses this file to you under the Apache License, Version |
| # 2.0 (the "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| # |
| |
| # Split arguments passed to a function into several lists separated by |
| # specified identifiers that do not have an associated list e.g.: |
| # |
| # SET(arguments |
| # hello world |
| # LIST3 foo bar |
| # LIST1 fuz baz |
| # ) |
| # ARGUMENT_SPLITTER("${arguments}" "LIST1 LIST2 LIST3" ARG) |
| # |
| # results in 8 distinct variables: |
| # * ARG_DEFAULT_FOUND: 1 |
| # * ARG_DEFAULT: hello;world |
| # * ARG_LIST1_FOUND: 1 |
| # * ARG_LIST1: fuz;baz |
| # * ARG_LIST2_FOUND: 0 |
| # * ARG_LIST2: |
| # * ARG_LIST3_FOUND: 1 |
| # * ARG_LIST3: foo;bar |
| |
| MACRO(INTERNAL_ARGUMENT_SPLITTER argInput argKeywordList argPrefix) |
| |
| SET(inputTokenList "DEFAULT" "${argInput}") |
| SET(keywordList "DEFAULT ${argKeywordList}") |
| SET(prefix ${argPrefix}) |
| |
| # convert provided inputTokenList to list |
| #SEPARATE_ARGUMENTS(inputTokenList) |
| SEPARATE_ARGUMENTS(keywordList) |
| |
| # initialize all out variables to default values |
| FOREACH(keyword ${keywordList}) |
| SET(${prefix}_${keyword}_FOUND 0) |
| SET(${prefix}_${keyword} "") |
| ENDFOREACH(keyword) |
| |
| # iterate all tokens of provided input |
| FOREACH(token ${inputTokenList}) |
| # check if current token is a keyword |
| SET(tokenIsKeyword 0) |
| FOREACH(keyword ${keywordList}) |
| IF ("${keyword}" STREQUAL "${token}") |
| SET(tokenIsKeyword 1) |
| SET(lastKeyword ${keyword}) |
| ENDIF ("${keyword}" STREQUAL "${token}") |
| ENDFOREACH(keyword) |
| |
| IF (${tokenIsKeyword}) |
| # if current token is keyword, set found variable to true |
| SET(${prefix}_${token}_FOUND 1) |
| ELSE (${tokenIsKeyword}) |
| # if current token is not keyword, append token to variable of last found keyword |
| SET(${prefix}_${lastKeyword} ${${prefix}_${lastKeyword}} ${token}) |
| ENDIF (${tokenIsKeyword}) |
| |
| |
| ENDFOREACH(token) |
| ENDMACRO(INTERNAL_ARGUMENT_SPLITTER) |
| |
| #MACRO(INTERNAL_ADD_OS_SUPPORT os) |
| # SET(SUPPORTED_OS ${os} ${ARGN}) |
| # SET(TARGET_OS ${os} CACHE STRINGS "Select target OS") |
| # SET_PROPERTY(CACHE TARGET_OS PROPERTY STRINGS ${SUPPORTED_OS}) |
| #ENDMACRO(INTERNAL_ADD_OS_SUPPORT) |
| |
| MACRO(INTERNAL_ADD_PREFIX var prefix) |
| SET(${var}) |
| IF(NOT "${ARGN}" STREQUAL "") |
| FOREACH(item ${ARGN}) |
| SET(${var} ${${var}} ${prefix}${item}) |
| ENDFOREACH(item) |
| ENDIF(NOT "${ARGN}" STREQUAL "") |
| ENDMACRO(INTERNAL_ADD_PREFIX) |
| |
| |
| MACRO(INTERNAL_SPLIT_PATH_AND_FILE file_with_path path filename) |
| GET_FILENAME_COMPONENT(${path} ${file_with_path} PATH) |
| IF(NOT "${${path}}" STREQUAL "") |
| SET(${path} "${${path}}/") |
| ENDIF() |
| GET_FILENAME_COMPONENT(${filename} ${file_with_path} NAME) |
| ENDMACRO(INTERNAL_SPLIT_PATH_AND_FILE) |
| |
| |
| MACRO(INTERNAL_GET_MODULE_NAME var) |
| GET_FILENAME_COMPONENT(${var} ${CMAKE_CURRENT_SOURCE_DIR} NAME) |
| ENDMACRO(INTERNAL_GET_MODULE_NAME) |
| |
| |
| MACRO(INTERNAL_GET_PUBLIC_INCLUDE_PATH var) |
| INTERNAL_GET_MODULE_NAME(gpip_module_name) |
| INTERNAL_GET_INTERN_INCLUDE_PATH(gpip_include_path) |
| SET(${var} "${gpip_include_path}/${gpip_module_name}") |
| ENDMACRO(INTERNAL_GET_PUBLIC_INCLUDE_PATH) |
| |
| |
| MACRO(INTERNAL_GET_INTERN_INCLUDE_PATH var) |
| SET(${var} ${CMAKE_CURRENT_SOURCE_DIR}/include) |
| ENDMACRO(INTERNAL_GET_INTERN_INCLUDE_PATH) |
| |
| |
| MACRO(INTERNAL_GET_PLATFORM_INCLUDE_PATH var gpi_classname) |
| INTERNAL_SPLIT_PATH_AND_FILE(${gpi_classname} gpi_path gpi_filename) |
| INTERNAL_GET_INTERN_INCLUDE_PATH(gpi_include_path) |
| #IF(NOT "${gpi_path}" STREQUAL "") |
| SET(${var} "${gpi_include_path}/${CURRENT_MODULE_NAME}/${gpi_path}arch") |
| #ELSE() |
| # SET(${var} "${gpi_include_path}/${CURRENT_MODULE_NAME}/arch") |
| #ENDIF() |
| |
| ENDMACRO(INTERNAL_GET_PLATFORM_INCLUDE_PATH) |
| |
| |
| MACRO(INTERNAL_GET_SOURCE_PATH var) |
| SET(${var} ${CMAKE_CURRENT_SOURCE_DIR}/src) |
| ENDMACRO(INTERNAL_GET_SOURCE_PATH) |
| |
| |
| MACRO(INTERNAL_GET_PLATFORM_SOURCE_PATH var gps_classname) |
| # INTERNAL_GET_SOURCE_PATH(gps_source_path) |
| # SET(${var} "${gps_source_path}/arch") |
| |
| INTERNAL_SPLIT_PATH_AND_FILE(${gps_classname} gps_path gps_filename) |
| INTERNAL_GET_SOURCE_PATH(gps_source_path) |
| SET(${var} "${gps_source_path}/${gps_path}arch") |
| ENDMACRO(INTERNAL_GET_PLATFORM_SOURCE_PATH) |
| |
| |
| MACRO(INTERNAL_GET_TEST_PATH var) |
| SET(${var} ${CMAKE_CURRENT_SOURCE_DIR}/test) |
| ENDMACRO(INTERNAL_GET_TEST_PATH) |
| |
| |
| MACRO(INTERNAL_GET_PATH_TO_FILES gsp_class) |
| INTERNAL_ARGUMENT_SPLITTER("${ARGN}" "PREFIX" GSP) |
| INTERNAL_SPLIT_PATH_AND_FILE(${gsp_class} GSP_PATH_TO_FILE GSP_FILENAME) |
| |
| STRING(TOUPPER ${GSP_FILENAME} gsp_varname) |
| IF(NOT "${GSP_PREFIX}" STREQUAL "") |
| SET(gsp_varname ${GSP_PREFIX}) |
| #ELSEIF(NOT "${GSP_PLATFORM}" STREQUAL "") |
| # STRING(TOUPPER ${GSP_PLATFORM} gsp_platform_varname) |
| # SET(gsp_varname ${gsp_platform_varname}${gsp_varname}) |
| |
| ENDIF() |
| |
| SET(gsp_all_classes ${gsp_class} ${GSP_DEFAULT_ARGS}) |
| |
| SET(${gsp_varname}_PUBLIC_HEADER) |
| SET(${gsp_varname}_INTERN_HEADER) |
| SET(${gsp_varname}_SOURCE_FILES) |
| |
| FOREACH(gsp_current_class ${gsp_all_classes}) |
| |
| INTERNAL_GET_PUBLIC_INCLUDE_PATH( gsp_public_include_path ) |
| |
| FOREACH(gsp_current_header_type ${HEADER_FILE_EXTENSIONS}) |
| SET(gsp_public_include_file "${gsp_public_include_path}/${gsp_current_class}.${gsp_current_header_type}" ) |
| |
| IF(EXISTS ${gsp_public_include_file}) |
| SET(${gsp_varname}_PUBLIC_HEADER ${${gsp_varname}_PUBLIC_HEADER} ${gsp_public_include_file}) |
| ENDIF() |
| |
| INTERNAL_GET_PLATFORM_INCLUDE_PATH( gsp_platform_include_path "${gsp_current_class}" ) |
| SET(gsp_generic_include_file "${gsp_platform_include_path}/${GSP_FILENAME}.${gsp_current_header_type}" ) |
| |
| IF(EXISTS ${gsp_generic_include_file}) |
| SET(${gsp_varname}_PUBLIC_HEADER ${${gsp_varname}_PUBLIC_HEADER} ${gsp_generic_include_file}) |
| ENDIF() |
| |
| INTERNAL_GET_INTERN_INCLUDE_PATH( gsp_intern_include_path ) |
| SET(gsp_intern_include_file "${gsp_intern_include_path}/${gsp_current_class}.${gsp_current_header_type}" ) |
| IF(EXISTS ${gsp_intern_include_file}) |
| SET(${gsp_varname}_INTERN_HEADER ${${gsp_varname}_INTERN_HEADER} ${gsp_intern_include_file}) |
| ELSE() |
| SET(gsp_intern_include_files "${gsp_platform_include_path}/${TARGET_OS}/${GSP_FILENAME}.${gsp_current_header_type}" "${gsp_platform_include_path}/${TARGET_OS}_${TARGET_ARCH}/${GSP_FILENAME}.${gsp_current_header_type}") |
| FOREACH(gsp_intern_include_file ${gsp_intern_include_files}) |
| IF(EXISTS ${gsp_intern_include_file}) |
| SET(${gsp_varname}_INTERN_HEADER ${${gsp_varname}_INTERN_HEADER} ${gsp_intern_include_file}) |
| ENDIF() |
| ENDFOREACH() |
| ENDIF() |
| ENDFOREACH() |
| |
| FOREACH(gsp_current_source_type ${SOURCE_FILE_EXTENSIONS}) |
| INTERNAL_GET_SOURCE_PATH(gsp_source_path) |
| SET(gsp_source_file "${gsp_source_path}/${gsp_current_class}.${gsp_current_source_type}" ) |
| IF(EXISTS ${gsp_source_file}) |
| SET(${gsp_varname}_SOURCE_FILES ${${gsp_varname}_SOURCE_FILES} ${gsp_source_file}) |
| ELSE() |
| INTERNAL_GET_PLATFORM_SOURCE_PATH(gsp_platform_source_path "${gsp_current_class}") |
| SET(gsp_source_files "${gsp_platform_source_path}/${TARGET_OS}/${GSP_FILENAME}.${gsp_current_source_type}" "${gsp_platform_source_path}/${TARGET_OS}_${TARGET_ARCH}/${GSP_FILENAME}.${gsp_current_source_type}") |
| FOREACH(gsp_source_file ${gsp_source_files}) |
| IF(EXISTS ${gsp_source_file}) |
| SET(${gsp_varname}_SOURCE_FILES ${${gsp_varname}_SOURCE_FILES} ${gsp_source_file}) |
| ENDIF() |
| ENDFOREACH() |
| ENDIF() |
| ENDFOREACH() |
| |
| INTERNAL_GET_TEST_PATH( gsp_test_path ) |
| SET(gsp_test_header "${gsp_test_path}/${gsp_current_class}Test.h") |
| SET(gsp_test_source "${gsp_test_path}/${gsp_current_class}Test.cpp") |
| |
| IF(EXISTS ${gsp_test_header}) |
| SET(${gsp_varname}_TEST_FILES ${${gsp_varname}_TEST_FILES} ${gsp_test_header}) |
| ENDIF() |
| |
| IF(EXISTS ${gsp_test_source}) |
| SET(${gsp_varname}_TEST_FILES ${${gsp_varname}_TEST_FILES} ${gsp_test_source}) |
| ENDIF() |
| |
| ENDFOREACH() |
| |
| ENDMACRO(INTERNAL_GET_PATH_TO_FILES) |
| |
| |
| MACRO(INTERNAL_ADD_FILE ac_name) |
| INTERNAL_ARGUMENT_SPLITTER("${ARGN}" "SOURCE_VAR TEST_VAR SOURCE_GROUP PREFIX CONDITIONS" AC) |
| |
| SET(ADD_FILE_CONDITIONS_MET 1) |
| FOREACH(CONDITION ${AC_CONDITIONS}) |
| IF (NOT ${CONDITION}) |
| MESSAGE(STATUS "Excluded class ${ac_name}, condition ${CONDITION} failed") |
| SET(ADD_FILE_CONDITIONS_MET 0) |
| ENDIF() |
| ENDFOREACH() |
| |
| IF(${ADD_FILE_CONDITIONS_MET}) |
| |
| SET(ac_all_classes ${ac_name} ${AC_DEFAULT_ARGS}) |
| |
| IF("${AC_PREFIX}" STREQUAL "") |
| INTERNAL_SPLIT_PATH_AND_FILE(${ac_name} ac_path ac_filename) |
| |
| STRING(TOUPPER ${ac_filename} ac_varname) |
| SET(AC_PREFIX ${ac_varname}) |
| ENDIF() |
| |
| INTERNAL_GET_PATH_TO_FILES(${ac_all_classes} PREFIX ${AC_PREFIX}) |
| IF(NOT "${${AC_PREFIX}_SOURCE_FILES}" STREQUAL "") |
| SET(${CURRENT_MODULE_NAME}_HAS_SOURCE_FILES 1 CACHE INTERNAL "") |
| ENDIF() |
| |
| IF(NOT "${AC_SOURCE_GROUP}" STREQUAL "") |
| SET(${AC_SOURCE_GROUP} ${${AC_SOURCE_GROUP}} ${${AC_PREFIX}_INTERN_HEADER} ${${AC_PREFIX}_SOURCE_FILES}) |
| ENDIF() |
| |
| IF(NOT "${AC_SOURCE_VAR}" STREQUAL "") |
| SET(${AC_SOURCE_VAR} ${${AC_SOURCE_VAR}} ${${AC_PREFIX}_PUBLIC_HEADER} ${${AC_PREFIX}_INTERN_HEADER} ${${AC_PREFIX}_SOURCE_FILES}) |
| ELSE() |
| SET(${CURRENT_UPPER_MODULE_NAME}_MODULE_SOURCE_FILES ${${CURRENT_UPPER_MODULE_NAME}_MODULE_SOURCE_FILES} ${${AC_PREFIX}_PUBLIC_HEADER} ${${AC_PREFIX}_INTERN_HEADER} ${${AC_PREFIX}_SOURCE_FILES}) |
| ENDIF() |
| |
| IF(NOT "${AC_TEST_VAR}" STREQUAL "") |
| SET(${AC_TEST_VAR} ${${AC_TEST_VAR}} ${${AC_PREFIX}_TEST_FILES}) |
| ELSE() |
| SET(${CURRENT_MODULE_NAME}_TEST_FILES ${${CURRENT_MODULE_NAME}_TEST_FILES} ${${AC_PREFIX}_TEST_FILES}) |
| ENDIF() |
| |
| ENDIF() |
| |
| ENDMACRO(INTERNAL_ADD_FILE) |
| |
| |
| MACRO(INTERNAL_ADD_OPTIONAL_FILE aoc_name) |
| INTERNAL_ARGUMENT_SPLITTER("${ARGN}" "SOURCE_VAR SOURCE_GROUP PREFIX CONDITIONS" AOC) |
| IF("${AOC_PREFIX}" STREQUAL "") |
| INTERNAL_SPLIT_PATH_AND_FILE(${aoc_name} aoc_path aoc_filename) |
| STRING(TOUPPER ${aoc_filename} aoc_varname) |
| SET(AOC_PREFIX ${aoc_varname}) |
| ENDIF() |
| |
| SET(aoc_temp_files) |
| set(aoc_temp_test) |
| |
| INTERNAL_ADD_FILE(${aoc_name} ${AOC_DEFAULT_ARGS} SOURCE_VAR aoc_temp_files TEST_VAR aoc_temp_test SOURCE_GROUP ${AOC_SOURCE_GROUP} PREFIX ${AOC_PREFIX} CONDITIONS ${AOC_CONDITIONS}) |
| INTERNAL_ADD_OPTIONAL_FILES(${CURRENT_UPPER_MODULE_NAME}_${AOC_PREFIX} SOURCE_FILES ${aoc_temp_files} TEST_FILES ${aoc_temp_test}) |
| |
| SET(${CURRENT_UPPER_MODULE_NAME}_SOURCE_FILES ${${CURRENT_UPPER_MODULE_NAME}_MODULE_SOURCE_FILES} ${${CURRENT_UPPER_MODULE_NAME}_${AOC_PREFIX}_SOURCE_FILES}) |
| SET(${CURRENT_MODULE_NAME}_TEST_FILES ${${CURRENT_MODULE_NAME}_TEST_FILES} ${${CURRENT_UPPER_MODULE_NAME}_${AOC_PREFIX}_TEST_FILES}) |
| ENDMACRO(INTERNAL_ADD_OPTIONAL_FILE) |
| |
| |
| MACRO(INTERNAL_ADD_SOURCE_FILES destination) |
| INTERNAL_ARGUMENT_SPLITTER("${ARGN}" "PUBLIC_HEADER INTERN_HEADER SOURCE_FILES" ARG) |
| SET(${destination} ${${destination}} ${ARG_PUBLIC_HEADER} ${ARG_INTERN_HEADER} ${ARG_SOURCE_FILES}) |
| ENDMACRO(INTERNAL_ADD_SOURCE_FILES) |
| |
| |
| MACRO(INTERNAL_ADD_OPTIONAL_FILES prefix) |
| INTERNAL_ARGUMENT_SPLITTER("${ARGN}" "SOURCE_FILES TEST_FILES" AOF) |
| |
| SET(${prefix}_ENABLE "on" CACHE BOOL "Enable ${prefix}" ) |
| SET(${prefix}_SOURCE_FILES) |
| SET(${prefix}_TEST_FILES) |
| |
| IF(${WITH_${CURRENT_UPPER_MODULE_NAME}}) |
| IF(${${prefix}_ENABLE}) |
| SET(${prefix}_SOURCE_FILES ${AOF_SOURCE_FILES}) |
| SET(${prefix}_TEST_FILES ${AOF_TEST_FILES}) |
| ENDIF() |
| ELSE() |
| INTERNAL_REMOVE_OPTIONAL_FILES(${prefix}) |
| ENDIF() |
| ENDMACRO(INTERNAL_ADD_OPTIONAL_FILES) |
| |
| |
| MACRO(INTERNAL_ADD_DEPENDENCY ad_name) |
| |
| IF("${ad_name}_FOUND") |
| |
| SET(${CURRENT_MODULE_NAME}_DEPENDENCIES ${${CURRENT_MODULE_NAME}_DEPENDENCIES} ${ad_name} ${${ad_name}_DEPENDENCIES} CACHE INTERNAL "") |
| |
| FOREACH(iad_dependency ${${ad_name}_DEPENDENCIES}) |
| INTERNAL_ADD_DEFINITION("${${iad_dependency}_DEPENDENT_DEFINITIONS}") |
| INTERNAL_ADD_DEBUG_DEFINITION("${${iad_dependency}_DEPENDENT_DEBUG_DEFINITIONS}") |
| INTERNAL_ADD_RELEASE_DEFINITION("${${iad_dependency}_DEPENDENT_RELEASE_DEFINITIONS}") |
| ENDFOREACH() |
| |
| INTERNAL_ADD_DEFINITION("${${ad_name}_DEPENDENT_DEFINITIONS}") |
| INTERNAL_ADD_DEBUG_DEFINITION("${${ad_name}_DEPENDENT_DEBUG_DEFINITIONS}") |
| INTERNAL_ADD_RELEASE_DEFINITION("${${ad_name}_DEPENDENT_RELEASE_DEFINITIONS}") |
| |
| ELSE() |
| MESSAGE(STATUS "WARNING: Required package '${ad_name}' was not found.") |
| MESSAGE(STATUS "WARNING: Build of '${CURRENT_MODULE_NAME}' was disabled.") |
| MESSAGE(STATUS "WARNING: Install package '${ad_name}' to enable build of '${CURRENT_MODULE_NAME}'.") |
| SET(${CURRENT_MODULE_NAME}_BUILD_ENABLED 0) |
| ENDIF() |
| |
| |
| #SET(${CURRENT_MODULE_NAME}_DEPENDENCIES ${${CURRENT_MODULE_NAME}_DEPENDENCIES} ${ad_name}) |
| ENDMACRO(INTERNAL_ADD_DEPENDENCY) |
| |
| MACRO(INTERNAL_LINK_LIBRARY ill_library) |
| |
| #LIST(FIND GLOBAL_LIBRARIES ${ill_library} FOUND_LIBRARY) |
| |
| #IF(${FOUND_LIBRARY} EQUAL -1) |
| # MESSAGE(FATAL_ERROR "You tried to link against the unknown lib ${ill_library}") |
| #ENDIF() |
| SET(${CURRENT_MODULE_NAME}_LIBRARIES ${${CURRENT_MODULE_NAME}_LIBRARIES} ${ill_library} ${ARGN} "" CACHE INTERNAL "") |
| ENDMACRO(INTERNAL_LINK_LIBRARY) |
| |
| MACRO(INTERNAL_LINK_LIBRARY_GROUP illg_library) |
| SET(${CURRENT_MODULE_NAME}_LIBRARIES ${${CURRENT_MODULE_NAME}_LIBRARIES} ${illg_library} ${ARGN}) |
| |
| INTERNAL_GROUP_LINK(${CURRENT_MODULE_NAME}_LIBRARIES ${${CURRENT_MODULE_NAME}_LIBRARIES}) |
| |
| ENDMACRO(INTERNAL_LINK_LIBRARY_GROUP) |
| |
| MACRO(INTERNAL_GROUP_LINK igl_libs) |
| IF("${TARGET_COMPILER}" STREQUAL "GCC") |
| SET(${igl_libs} "-Wl,--start-group" ${ARGN} "-Wl,--end-group") |
| ENDIF() |
| ENDMACRO(INTERNAL_GROUP_LINK) |
| |
| |
| MACRO(INTERNAL_JUST_DOIT) |
| IF(${WITH_${CURRENT_UPPER_MODULE_NAME}} AND ${${CURRENT_MODULE_NAME}_BUILD_ENABLED}) |
| |
| INTERNAL_GET_INTERN_INCLUDE_PATH(asl_intern_include_path) |
| |
| INCLUDE_DIRECTORIES(${asl_intern_include_path}) |
| |
| SET(jd_collected_dependencies "${${CURRENT_MODULE_NAME}_PACKAGE_LIBS}" "${${CURRENT_MODULE_NAME}_LIBRARIES}") |
| |
| SET(jdi_include_dirs "") |
| FOREACH(dependency ${${CURRENT_MODULE_NAME}_DEPENDENCIES}) |
| IF(EXISTS "${PROJECT_SOURCE_DIR}/modules/${dependency}/include") |
| SET(jdi_include_dirs ${jdi_include_dirs} "${PROJECT_SOURCE_DIR}/modules/${dependency}/include") |
| ELSEIF(DEFINED ${dependency}_INCLUDE_DIR) |
| SET(jdi_include_dirs ${jdi_include_dirs} "${${dependency}_INCLUDE_DIR}") |
| SET(GLOBAL_EXTERN_INCLUDE_DIRS ${GLOBAL_EXTERN_INCLUDE_DIRS} "${${dependency}_INCLUDE_DIR}" CACHE INTERNAL "collect extern include dirs") |
| ELSE() |
| MESSAGE(FATAL_ERROR "Added unknown dependency ${dependency}") |
| ENDIF() |
| ENDFOREACH() |
| |
| |
| |
| IF(${${CURRENT_MODULE_NAME}_HAS_SOURCE_FILES}) |
| |
| #FOREACH(dependency ${${CURRENT_MODULE_NAME}_DEPENDENCIES}) |
| # SET(jd_dependency_linker_dirs ${jd_dependency_linker_dirs} "${${dependency}_LIBRARIES_DIR}") |
| # ENDFOREACH() |
| |
| # IF(NOT "${jd_dependency_linker_dirs}" STREQUAL "") |
| # LIST(REMOVE_DUPLICATES jd_dependency_linker_dirs) |
| # ENDIF() |
| LINK_DIRECTORIES(${GLOBAL_LIB_DIRECTORIES}) |
| |
| |
| |
| |
| IF(${CURRENT_MODULE_TYPE} STREQUAL "STATIC") |
| SET(UTILS_MODULES_STATIC ${UTILS_MODULES_STATIC} ${CURRENT_MODULE_NAME} CACHE INTERNAL "") |
| ADD_LIBRARY(${CURRENT_MODULE_NAME} |
| STATIC |
| ${${CURRENT_UPPER_MODULE_NAME}_MODULE_SOURCE_FILES} |
| ) |
| SET(GLOBAL_LIBRARIES ${GLOBAL_LIBRARIES} ${CURRENT_MODULE_NAME} CACHE INTERNAL "collect all linkable libraries") |
| ELSEIF(${CURRENT_MODULE_TYPE} STREQUAL "DYNAMIC") |
| SET(UTILS_MODULES_DYNAMIC ${UTILS_MODULES_DYNAMIC} ${CURRENT_MODULE_NAME} CACHE INTERNAL "") |
| ADD_LIBRARY(${CURRENT_MODULE_NAME} |
| SHARED |
| ${${CURRENT_UPPER_MODULE_NAME}_MODULE_SOURCE_FILES} |
| ) |
| ELSEIF(${CURRENT_MODULE_TYPE} STREQUAL "EXE") |
| SET(UTILS_MODULES_EXE ${UTILS_MODULES_EXE} ${CURRENT_MODULE_NAME} CACHE INTERNAL "") |
| ADD_EXECUTABLE(${CURRENT_MODULE_NAME} |
| ${${CURRENT_UPPER_MODULE_NAME}_MODULE_SOURCE_FILES} |
| ) |
| ENDIF() |
| |
| INTERNAL_ADD_DEBUG_COMPILER_FLAGS_TO_TARGET(${CURRENT_MODULE_NAME} ${${CURRENT_MODULE_NAME}_DEBUG_COMPILER_FLAGS}) |
| INTERNAL_ADD_RELEASE_COMPILER_FLAGS_TO_TARGET(${CURRENT_MODULE_NAME} ${${CURRENT_MODULE_NAME}_RELEASE_COMPILER_FLAGS}) |
| |
| INTERNAL_ADD_DEBUG_LINKER_FLAGS_TO_TARGET(${CURRENT_MODULE_NAME} ${${CURRENT_MODULE_NAME}_DEBUG_LINKER_FLAGS}) |
| INTERNAL_ADD_RELEASE_LINKER_FLAGS_TO_TARGET(${CURRENT_MODULE_NAME} ${${CURRENT_MODULE_NAME}_RELEASE_LINKER_FLAGS}) |
| |
| INTERNAL_ADD_DEBUG_DEFINITIONS_TO_TARGET(${CURRENT_MODULE_NAME} ${${CURRENT_MODULE_NAME}_DEBUG_DEFINITIONS}) |
| INTERNAL_ADD_RELEASE_DEFINITIONS_TO_TARGET(${CURRENT_MODULE_NAME} ${${CURRENT_MODULE_NAME}_RELEASE_DEFINITIONS}) |
| |
| INCLUDE_DIRECTORIES(${jdi_include_dirs}) |
| |
| |
| IF(NOT "${${CURRENT_MODULE_NAME}_DEPENDENCIES}" STREQUAL "") |
| # FOREACH(current_dependency ${${CURRENT_MODULE_NAME}_DEPENDENCIES}) |
| # IF((${${current_dependency}_HAS_SOURCE_FILES}) AND NOT( "${${current_dependency}_MODULE_TYPE}" STREQUAL "EXE")) |
| # SET(jd_collected_dependencies ${jd_collected_dependencies} "${current_dependency}") |
| # ELSEIF(DEFINED ${current_dependency}_LIBRARIES) |
| # SET(jd_collected_dependencies ${jd_collected_dependencies} ${current_dependency}) |
| # ENDIF() |
| # ENDFOREACH() |
| ADD_DEPENDENCIES(${CURRENT_MODULE_NAME} ${${CURRENT_MODULE_NAME}_DEPENDENCIES}) |
| ENDIF() |
| |
| IF(NOT "${${CURRENT_MODULE_NAME}_LIBRARIES}" STREQUAL "" AND NOT "${CURRENT_MODULE_TYPE}" STREQUAL "STATIC") |
| TARGET_LINK_LIBRARIES(${CURRENT_MODULE_NAME} ${${CURRENT_MODULE_NAME}_LIBRARIES} ${jd_collected_dependencies}) |
| ENDIF() |
| |
| SET_TARGET_PROPERTIES(${CURRENT_MODULE_NAME} PROPERTIES LINKER_LANGUAGE CXX) |
| ELSE() |
| ADD_CUSTOM_TARGET(${CURRENT_MODULE_NAME} SOURCES |
| ${${CURRENT_UPPER_MODULE_NAME}_MODULE_SOURCE_FILES} |
| ) |
| ENDIF() |
| |
| IF(NOT "${${CURRENT_MODULE_NAME}_TEST_FILES}" STREQUAL "") |
| SET(UTILS_MODULES_TESTS ${UTILS_MODULES_TESTS} ${CURRENT_MODULE_NAME}Test CACHE INTERNAL "") |
| |
| SET(EXTERNAL_PACKAGE_LINK_DIRECTORIES "") |
| FOREACH(current_dependency ${${CURRENT_MODULE_NAME}_DEPENDENCIES}) |
| IF(${${current_dependency}_HAS_SOURCE_FILES}) |
| SET(jd_collected_dependencies ${jd_collected_dependencies} ${current_dependency}) |
| ENDIF() |
| IF(DEFINED ${current_dependency}_LIBRARIES_DIR) |
| SET(EXTERNAL_PACKAGE_LINK_DIRECTORIES ${EXTERNAL_PACKAGE_LINK_DIRECTORIES} "${${current_dependency}_LIBRARIES_DIR}") |
| ENDIF() |
| ENDFOREACH() |
| |
| IF(NOT "${jd_collected_dependencies}" STREQUAL "") |
| list(REMOVE_DUPLICATES jd_collected_dependencies) |
| ENDIF() |
| |
| IF(${BUILD_UNITTESTS}) |
| |
| IF(${BUILD_GLOBAL_TEST_EXECUTABLE}) |
| #ADD_LIBRARY(${CURRENT_MODULE_NAME}Test STATIC ${${CURRENT_MODULE_NAME}_TEST_FILES}) |
| SET(GLOBAL_TEST_INCLUDE_DIRECTORIES ${GLOBAL_TEST_INCLUDE_DIRECTORIES} ${jdi_include_dirs} ${asl_intern_include_path} CACHE INTERNAL "collect test include directories") |
| SET(GLOBAL_TEST_LIBS ${GLOBAL_TEST_LIBS} ${jd_collected_dependencies} CACHE INTERNAL "collect test libs") |
| IF(${${CURRENT_MODULE_NAME}_HAS_SOURCE_FILES}) |
| SET(GLOBAL_TEST_LIBS ${GLOBAL_TEST_LIBS} ${CURRENT_MODULE_NAME} CACHE INTERNAL "collect test libs") |
| ENDIF() |
| |
| SET(GLOBAL_TEST_SOURCE ${GLOBAL_TEST_SOURCE} ${${CURRENT_MODULE_NAME}_TEST_FILES} CACHE INTERNAL "collect test source") |
| SET(GLOBAL_TEST_LINKER_DIRECTORIES ${GLOBAL_TEST_LINKER_DIRECTORIES} "${EXTERNAL_PACKAGE_LINK_DIRECTORIES}" CACHE INTERNAL "collect test linker directories") |
| |
| SET(GLOBAL_TEST_DEBUG_COMPILER_FLAGS ${GLOBAL_TEST_DEBUG_COMPILER_FLAGS} ${${CURRENT_MODULE_NAME}_DEBUG_COMPILER_FLAGS} CACHE INTERNAL "collect test compiler flags") |
| SET(GLOBAL_TEST_RELEASE_COMPILER_FLAGS ${GLOBAL_TEST_RELEASE_COMPILER_FLAGS} ${${CURRENT_MODULE_NAME}_RELEASE_COMPILER_FLAGS} CACHE INTERNAL "collect test compiler flags") |
| |
| SET(GLOBAL_TEST_DEBUG_LINKER_FLAGS ${GLOBAL_TEST_DEBUG_LINKER_FLAGS} ${${CURRENT_MODULE_NAME}_DEBUG_LINKER_FLAGS} CACHE INTERNAL "collect test linker flags") |
| SET(GLOBAL_TEST_RELEASE_LINKER_FLAGS ${GLOBAL_TEST_RELEASE_LINKER_FLAGS} ${${CURRENT_MODULE_NAME}_RELEASE_LINKER_FLAGS} CACHE INTERNAL "collect test linker flags") |
| |
| SET(GLOBAL_TEST_DEBUG_DEFINITIONS ${GLOBAL_TEST_DEBUG_DEFINITIONS} ${${CURRENT_MODULE_NAME}_DEBUG_DEFINITIONS} CACHE INTERNAL "collect test definitions") |
| SET(GLOBAL_TEST_RELEASE_DEFINITIONS ${GLOBAL_TEST_RELEASE_DEFINITIONS} ${${CURRENT_MODULE_NAME}_RELEASE_DEFINITIONS} CACHE INTERNAL "collect test definitions") |
| |
| ELSE() |
| |
| IF(${${CURRENT_MODULE_NAME}_HAS_SOURCE_FILES}) |
| SET(jd_collected_dependencies ${jd_collected_dependencies} ${CURRENT_MODULE_NAME}) |
| ENDIF() |
| |
| INTERNAL_GET_TEST_PATH(jd_test_path) |
| SET(${CURRENT_MODULE_NAME}_TEST_MAIN "") |
| IF(EXISTS "${jd_test_path}/main.cpp") |
| SET(${CURRENT_MODULE_NAME}_TEST_MAIN "${jd_test_path}/main.cpp") |
| ELSE() |
| SET(jd_collected_dependencies "${jd_collected_dependencies}" gtest_main gmock_main) |
| ENDIF() |
| |
| LINK_DIRECTORIES(${GoogleTest_LIBRARIES_DIR} ${GoogleMock_LIBRARIES_DIR} ${EXTERNAL_PACKAGE_LINK_DIRECTORIES}) |
| ADD_EXECUTABLE(${CURRENT_MODULE_NAME}Test ${${CURRENT_MODULE_NAME}_TEST_FILES} ${${CURRENT_MODULE_NAME}_TEST_MAIN}) |
| |
| INTERNAL_ADD_DEBUG_COMPILER_FLAGS_TO_TARGET(${CURRENT_MODULE_NAME}Test ${${CURRENT_MODULE_NAME}_DEBUG_COMPILER_FLAGS}) |
| INTERNAL_ADD_RELEASE_COMPILER_FLAGS_TO_TARGET(${CURRENT_MODULE_NAME}Test ${${CURRENT_MODULE_NAME}_RELEASE_COMPILER_FLAGS}) |
| |
| INTERNAL_ADD_DEBUG_LINKER_FLAGS_TO_TARGET(${CURRENT_MODULE_NAME}Test ${${CURRENT_MODULE_NAME}_DEBUG_LINKER_FLAGS}) |
| INTERNAL_ADD_RELEASE_LINKER_FLAGS_TO_TARGET(${CURRENT_MODULE_NAME}Test ${${CURRENT_MODULE_NAME}_RELEASE_LINKER_FLAGS}) |
| |
| INTERNAL_ADD_DEBUG_DEFINITIONS_TO_TARGET(${CURRENT_MODULE_NAME}Test ${${CURRENT_MODULE_NAME}_DEBUG_DEFINITIONS}) |
| INTERNAL_ADD_RELEASE_DEFINITIONS_TO_TARGET(${CURRENT_MODULE_NAME}Test ${${CURRENT_MODULE_NAME}_RELEASE_DEFINITIONS}) |
| |
| INCLUDE_DIRECTORIES(${GoogleTest_INCLUDE_DIR} ${GoogleMock_INCLUDE_DIR} ${jdi_include_dirs}) |
| MESSAGE(STATUS "${CURRENT_MODULE_NAME} contains unit tests, building ${CURRENT_MODULE_NAME}Test") |
| |
| INTERNAL_GROUP_LINK(jd_collected_dependencies ${jd_collected_dependencies}) |
| |
| TARGET_LINK_LIBRARIES(${CURRENT_MODULE_NAME}Test ${GoogleMock_LIBRARIES} ${GoogleTest_LIBRARIES} ${jd_collected_dependencies}) |
| ADD_DEPENDENCIES(${CURRENT_MODULE_NAME}Test GoogleMock ${CURRENT_MODULE_NAME}) |
| |
| ENDIF() |
| |
| ENDIF() |
| |
| ENDIF() |
| |
| # copy header files |
| |
| IF(EXISTS "${${CURRENT_MODULE_NAME}_DIR}/include/${CURRENT_MODULE_NAME}") |
| INSTALL(DIRECTORY ${${CURRENT_MODULE_NAME}_DIR}/include/${CURRENT_MODULE_NAME} DESTINATION "${CMAKE_HEADER_OUTPUT_DIRECTORY}/${CMAKE_PROJECT_NAME}" PATTERN ".svn" EXCLUDE) |
| ENDIF() |
| |
| # copy resource files |
| |
| FILE(GLOB_RECURSE jdi_ressource_files "${${CURRENT_MODULE_NAME}_DIR}/res/*.*") |
| FILE(GLOB_RECURSE jdi_exclude_files "${${CURRENT_MODULE_NAME}_DIR}/res/.svn/*") |
| IF(NOT "${jdi_exclude_files}" STREQUAL "") |
| LIST(REMOVE_ITEM jdi_ressource_files ${jdi_exclude_files}) |
| ENDIF() |
| INSTALL(FILES ${jdi_ressource_files} DESTINATION "${CMAKE_RESOURCE_OUTPUT_DIRECTORY}/${CURRENT_MODULE_NAME}") |
| |
| # copy doc files |
| |
| FILE(GLOB_RECURSE jdi_doc_files "${${CURRENT_MODULE_NAME}_DIR}/doc/*.*") |
| FILE(GLOB_RECURSE jdi_exclude_files "${${CURRENT_MODULE_NAME}_DIR}/doc/.svn/*") |
| IF(NOT "${jdi_exclude_files}" STREQUAL "") |
| LIST(REMOVE_ITEM jdi_doc_files ${jdi_exclude_files}) |
| ENDIF() |
| INSTALL(FILES ${jdi_doc_files} DESTINATION "${CMAKE_DOC_OUTPUT_DIRECTORY}/${CURRENT_MODULE_NAME}") |
| |
| IF(NOT "${${CURRENT_MODULE_NAME}_INSTALL_FILES}" STREQUAL "") |
| INSTALL(FILES ${${CURRENT_MODULE_NAME}_INSTALL_FILES} DESTINATION "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/\${BUILD_TYPE}") |
| ENDIF() |
| |
| ENDIF() |
| ENDMACRO(INTERNAL_JUST_DOIT) |
| |
| #MACRO(INTERNAL_ADD_COMPILER_FLAGS_TO_TARGET acf_target acf_flags) |
| # SET_TARGET_PROPERTIES(${acf_target} PROPERTIES COMPILE_FLAGS "${acf_flags}" ) |
| #ENDMACRO(INTERNAL_ADD_COMPILER_FLAGS_TO_TARGET) |
| |
| #MACRO(INTERNAL_ADD_LINKER_FLAGS_TO_TARGET alf_target alf_flags) |
| # SET_TARGET_PROPERTIES(${alf_target} PROPERTIES LINK_FLAGS "${alf_flags}" ) |
| #ENDMACRO(INTERNAL_ADD_LINKER_FLAGS_TO_TARGET) |
| |
| #MACRO(INTERNAL_ADD_DEFINITIONS_TO_TARGET adt_target adt_definitions) |
| # SET_TARGET_PROPERTIES(${adt_target} PROPERTIES COMPILE_DEFINITIONS "${adt_definitions}" ) |
| #ENDMACRO(INTERNAL_ADD_DEFINITIONS_TO_TARGET) |
| |
| MACRO(INTERNAL_ADD_DEBUG_COMPILER_FLAGS_TO_TARGET acf_target) |
| INTERNAL_LIST_TO_STRING("${ARGN}" acf_flags) |
| SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${acf_flags}") |
| SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${acf_flags}") |
| ENDMACRO(INTERNAL_ADD_DEBUG_COMPILER_FLAGS_TO_TARGET) |
| |
| MACRO(INTERNAL_ADD_DEBUG_LINKER_FLAGS_TO_TARGET alf_target) |
| SET_TARGET_PROPERTIES(${alf_target} PROPERTIES LINK_FLAGS_DEBUG "${ARGN}" ) |
| ENDMACRO(INTERNAL_ADD_DEBUG_LINKER_FLAGS_TO_TARGET) |
| |
| MACRO(INTERNAL_ADD_DEBUG_DEFINITIONS_TO_TARGET adt_target ) |
| SET_TARGET_PROPERTIES(${adt_target} PROPERTIES COMPILE_DEFINITIONS_DEBUG "${ARGN}" ) |
| ENDMACRO(INTERNAL_ADD_DEBUG_DEFINITIONS_TO_TARGET) |
| |
| MACRO(INTERNAL_ADD_RELEASE_COMPILER_FLAGS_TO_TARGET acf_target) |
| INTERNAL_LIST_TO_STRING("${ARGN}" acf_flags) |
| SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${acf_flags}") |
| SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${acf_flags}") |
| ENDMACRO(INTERNAL_ADD_RELEASE_COMPILER_FLAGS_TO_TARGET) |
| |
| MACRO(INTERNAL_ADD_RELEASE_LINKER_FLAGS_TO_TARGET alf_target ) |
| SET_TARGET_PROPERTIES(${alf_target} PROPERTIES LINK_FLAGS_RELEASE "${ARGN}" ) |
| ENDMACRO(INTERNAL_ADD_RELEASE_LINKER_FLAGS_TO_TARGET) |
| |
| MACRO(INTERNAL_ADD_RELEASE_DEFINITIONS_TO_TARGET adt_target ) |
| SET_TARGET_PROPERTIES(${adt_target} PROPERTIES COMPILE_DEFINITIONS_RELEASE "${ARGN}" ) |
| ENDMACRO(INTERNAL_ADD_RELEASE_DEFINITIONS_TO_TARGET) |
| |
| |
| MACRO(INTERNAL_REPORT_MODULE) |
| INTERNAL_ARGUMENT_SPLITTER("${ARGN}" "TYPE MODULES" RM) |
| MESSAGE(STATUS) |
| MESSAGE("Building ${RM_TYPE} modules:") |
| MESSAGE(STATUS) |
| FOREACH(r_module ${RM_MODULES}) |
| MESSAGE(STATUS "${r_module}") |
| ENDFOREACH() |
| MESSAGE(STATUS) |
| ENDMACRO(INTERNAL_REPORT_MODULE) |
| |
| |
| MACRO(INTERNAL_REPORT) |
| MESSAGE(STATUS) |
| MESSAGE(STATUS "-------------------------------------------------------------------") |
| MESSAGE(STATUS "------------------- Configuration report begin --------------------") |
| MESSAGE(STATUS "-------------------------------------------------------------------") |
| |
| IF(NOT "${UTILS_MODULES_STATIC}" STREQUAL "") |
| INTERNAL_REPORT_MODULE(TYPE static MODULES ${UTILS_MODULES_STATIC}) |
| MESSAGE(STATUS "-------------------------------------------------------------------") |
| ENDIF() |
| |
| IF(NOT "${UTILS_MODULES_DYNAMIC}" STREQUAL "") |
| INTERNAL_REPORT_MODULE(TYPE dynamic MODULES ${UTILS_MODULES_DYNAMIC}) |
| MESSAGE(STATUS "-------------------------------------------------------------------") |
| ENDIF() |
| |
| IF(NOT "${UTILS_MODULES_EXE}" STREQUAL "") |
| INTERNAL_REPORT_MODULE(TYPE executables MODULES ${UTILS_MODULES_EXE}) |
| MESSAGE(STATUS "-------------------------------------------------------------------") |
| ENDIF() |
| |
| IF(NOT "${UTILS_MODULES_TESTS}" STREQUAL "") |
| INTERNAL_REPORT_MODULE(TYPE tests MODULES ${UTILS_MODULES_TESTS}) |
| MESSAGE(STATUS "-------------------------------------------------------------------") |
| ENDIF() |
| MESSAGE(STATUS "------------------- Configuration report end ----------------------") |
| MESSAGE(STATUS "-------------------------------------------------------------------") |
| MESSAGE(STATUS) |
| ENDMACRO(INTERNAL_REPORT) |
| |
| |
| MACRO(INTERNAL_REMOVE_OPTIONAL_FILES prefix) |
| UNSET(${prefix}_ENABLE CACHE) |
| ENDMACRO(INTERNAL_REMOVE_OPTIONAL_FILES) |
| |
| |
| MACRO(INTERNAL_ADD_MODULE_INTERNAL ami_module_name ami_type) |
| MESSAGE("---------------------------------------------------------------------------") |
| MESSAGE(STATUS "Configuring build for ${ami_module_name} (${ami_type})") |
| STRING(TOUPPER ${ami_type} CURRENT_MODULE_TYPE) |
| SET(CURRENT_MODULE_NAME ${ami_module_name}) |
| STRING(TOUPPER ${CURRENT_MODULE_NAME} CURRENT_UPPER_MODULE_NAME) |
| SET(${CURRENT_MODULE_NAME}_HAS_SOURCE_FILES 0 CACHE INTERNAL "") |
| SET(${CURRENT_MODULE_NAME}_MODULE_TYPE "${CURRENT_MODULE_TYPE}" CACHE INTERNAL "") |
| SET(${CURRENT_MODULE_NAME}_DIR "${CMAKE_CURRENT_SOURCE_DIR}" CACHE INTERNAL "") |
| SET(${CURRENT_MODULE_NAME}_BUILD_ENABLED 1) |
| SET(${CURRENT_MODULE_NAME}_COMPILE_FLAGS "" CACHE INTERNAL "") |
| SET(${CURRENT_MODULE_NAME}_DEBUG_COMPILER_FLAGS "" CACHE INTERNAL "") |
| SET(${CURRENT_MODULE_NAME}_RELEASE_COMPILER_FLAGS "" CACHE INTERNAL "") |
| SET(${CURRENT_MODULE_NAME}_LINKER_FLAGS "" CACHE INTERNAL "") |
| SET(${CURRENT_MODULE_NAME}_DEBUG_LINKER_FLAGS "" CACHE INTERNAL "") |
| SET(${CURRENT_MODULE_NAME}_RELEASE_LINKER_FLAGS "" CACHE INTERNAL "") |
| SET(${CURRENT_MODULE_NAME}_DEBUG_DEFINITIONS "" CACHE INTERNAL "") |
| SET(${CURRENT_MODULE_NAME}_RELEASE_DEFINITIONS "" CACHE INTERNAL "") |
| SET(${CURRENT_MODULE_NAME}_DEPENDENCIES "" CACHE INTERNAL "") |
| SET(${CURRENT_MODULE_NAME}_LIBRARIES "" CACHE INTERNAL "") |
| SET(${CURRENT_MODULE_NAME}_INSTALL_FILES "" CACHE INTERNAL "") |
| SET(${CURRENT_MODULE_NAME}_PACKAGE_LIBS "" CACHE INTERNAL "") |
| SET(${CURRENT_MODULE_NAME}_FOUND 1 CACHE INTERNAL "") |
| ENDMACRO(INTERNAL_ADD_MODULE_INTERNAL) |
| |
| |
| MACRO(INTERNAL_ADD_INSTALL_FILE iaif_filename) |
| SET(${CURRENT_MODULE_NAME}_INSTALL_FILES ${${CURRENT_MODULE_NAME}_INSTALL_FILES} "${iaif_filename}" CACHE INTERNAL "") |
| ENDMACRO(INTERNAL_ADD_INSTALL_FILE) |
| |
| MACRO(INTERNAL_ADD_MODULE ad_module_name ad_type) |
| INTERNAL_ADD_MODULE_INTERNAL(${ad_module_name} ${ad_type}) |
| SET(WITH_${CURRENT_UPPER_MODULE_NAME} 1 CACHE INTERNAL "Use module ${CURRENT_UPPER_MODULE_NAME}") |
| ENDMACRO(INTERNAL_ADD_MODULE) |
| |
| |
| MACRO(INTERNAL_ADD_OPTIONAL_MODULE aom_module_name aom_type) |
| INTERNAL_ADD_MODULE_INTERNAL(${aom_module_name} ${aom_type}) |
| SET(WITH_${CURRENT_UPPER_MODULE_NAME} 1 CACHE BOOL "Use module ${CURRENT_UPPER_MODULE_NAME}") |
| ENDMACRO(INTERNAL_ADD_OPTIONAL_MODULE) |
| |
| |
| MACRO(INTERNAL_ADD_COMPILER_FLAG aicf_compiler_flag) |
| INTERNAL_ADD_DEBUG_COMPILER_FLAG(${aicf_compiler_flag}) |
| INTERNAL_ADD_RELEASE_COMPILER_FLAG(${aicf_compiler_flag}) |
| ENDMACRO(INTERNAL_ADD_COMPILER_FLAG) |
| |
| MACRO(INTERNAL_ADD_DEBUG_COMPILER_FLAG aidcf_compiler_flag) |
| SET(${CURRENT_MODULE_NAME}_DEBUG_COMPILER_FLAGS ${${CURRENT_MODULE_NAME}_DEBUG_COMPILER_FLAGS} ${aidcf_compiler_flag} CACHE INTERNAL "") |
| ENDMACRO(INTERNAL_ADD_DEBUG_COMPILER_FLAG) |
| |
| MACRO(INTERNAL_ADD_RELEASE_COMPILER_FLAG iarcf_compiler_flag) |
| SET(${CURRENT_MODULE_NAME}_RELEASE_COMPILER_FLAGS ${${CURRENT_MODULE_NAME}_RELEASE_COMPILER_FLAGS} ${iarcf_compiler_flag} CACHE INTERNAL "") |
| ENDMACRO(INTERNAL_ADD_RELEASE_COMPILER_FLAG) |
| |
| |
| |
| MACRO(INTERNAL_ADD_DEFINITION iad_definition) |
| INTERNAL_ADD_RELEASE_DEFINITION("${iad_definition}") |
| INTERNAL_ADD_DEBUG_DEFINITION("${iad_definition}") |
| ENDMACRO(INTERNAL_ADD_DEFINITION) |
| |
| MACRO(INTERNAL_ADD_DEBUG_DEFINITION iadd_definition) |
| SET(${CURRENT_MODULE_NAME}_DEBUG_DEFINITIONS "${${CURRENT_MODULE_NAME}_DEBUG_DEFINITIONS}" ${iadd_definition} CACHE INTERNAL "") |
| ENDMACRO(INTERNAL_ADD_DEBUG_DEFINITION) |
| |
| MACRO(INTERNAL_ADD_RELEASE_DEFINITION iard_definition) |
| SET(${CURRENT_MODULE_NAME}_RELEASE_DEFINITIONS "${${CURRENT_MODULE_NAME}_RELEASE_DEFINITIONS}" ${iard_definition} CACHE INTERNAL "") |
| ENDMACRO(INTERNAL_ADD_RELEASE_DEFINITION) |
| |
| #MACRO(INTERNAL_ADD_DEBUG_COMPILER_FLAG adcf_compiler_flag) |
| # SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} ${adcf_compiler_flag}") |
| # SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${adcf_compiler_flag}") |
| #ENDMACRO(INTERNAL_ADD_DEBUG_COMPILER_FLAG) |
| |
| |
| #MACRO(INTERNAL_ADD_RELEASE_COMPILER_FLAG arcf_compiler_flag) |
| #SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} ${arcf_compiler_flag}") |
| # SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${arcf_compiler_flag}") |
| #ENDMACRO(INTERNAL_ADD_RELEASE_COMPILER_FLAG) |
| |
| |
| MACRO(INTERNAL_ADD_LINKER_FLAG ialf_linker_flag) |
| INTERNAL_ADD_DEBUG_LINKER_FLAG(${ialf_linker_flag}) |
| INTERNAL_ADD_RELEASE_LINKER_FLAG(${ialf_linker_flag}) |
| #SET(${CURRENT_MODULE_NAME}_LINKER_FLAGS ${${CURRENT_MODULE_NAME}_LINKER_FLAGS} ${ad_linker_flag} CACHE INTERNAL "") |
| ENDMACRO(INTERNAL_ADD_LINKER_FLAG) |
| |
| MACRO(INTERNAL_ADD_DEBUG_LINKER_FLAG aadl_linker_flag) |
| SET(${CURRENT_MODULE_NAME}_DEBUG_LINKER_FLAGS "${${CURRENT_MODULE_NAME}_DEBUG_LINKER_FLAGS} ${aadl_linker_flag}" CACHE INTERNAL "") |
| ENDMACRO(INTERNAL_ADD_DEBUG_LINKER_FLAG) |
| |
| MACRO(INTERNAL_ADD_RELEASE_LINKER_FLAG iarl_linker_flag) |
| SET(${CURRENT_MODULE_NAME}_RELEASE_LINKER_FLAGS "${${CURRENT_MODULE_NAME}_RELEASE_LINKER_FLAGS} ${iarl_linker_flag}" CACHE INTERNAL "") |
| ENDMACRO(INTERNAL_ADD_RELEASE_LINKER_FLAG) |
| |
| |
| |
| MACRO(INTERNAL_FINALIZE) |
| INTERNAL_BUILD_UNIT_TESTS() |
| list(REMOVE_DUPLICATES GLOBAL_EXTERN_INCLUDE_DIRS) |
| |
| #FILE(WRITE "${CMAKE_CMAKE_OUTPUT_DIRECTORY}/${CMAKE_PROJECT_NAME}.cmake" "SET(${CMAKE_PROJECT_NAME}_INCLUDE_DIR \"${GLOBAL_EXTERN_INCLUDE_DIRS} ${CMAKE_INSTALL_PREFIX}/${CMAKE_HEADER_OUTPUT_DIRECTORY}/${CMAKE_PROJECT_NAME}\")") |
| |
| REPORT() |
| ENDMACRO(INTERNAL_FINALIZE) |
| |
| MACRO(INTERNAL_BUILD_UNIT_TESTS) |
| IF(${BUILD_GLOBAL_TEST_EXECUTABLE} AND NOT "${GLOBAL_TEST_SOURCE}" STREQUAL "") |
| #SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_SOURCE_DIR}/deliverable/bin") |
| #ADD_DEBUG_COMPILER_FLAG("/MTd") |
| #ADD_RELEASE_COMPILER_FLAG("/MT") |
| |
| LINK_DIRECTORIES(${GoogleTest_LIBRARIES_DIR} ${GoogleMock_LIBRARIES_DIR} ${GLOBAL_TEST_LINKER_DIRECTORIES}) |
| message("global include ${GLOBAL_TEST_INCLUDE_DIRECTORIES}") |
| INCLUDE_DIRECTORIES(${GoogleTest_INCLUDE_DIR} ${GoogleMock_INCLUDE_DIR} ${GLOBAL_TEST_INCLUDE_DIRECTORIES}) |
| MESSAGE(STATUS "Global unit test executable enabled, building Test") |
| ADD_EXECUTABLE(Test ${GLOBAL_TEST_SOURCE}) |
| |
| INTERNAL_ADD_DEBUG_COMPILER_FLAGS_TO_TARGET(Test ${GLOBAL_TEST_DEBUG_COMPILER_FLAGS}) |
| INTERNAL_ADD_RELEASE_COMPILER_FLAGS_TO_TARGET(Test ${GLOBAL_TEST_RELEASE_COMPILER_FLAGS}) |
| |
| INTERNAL_ADD_DEBUG_LINKER_FLAGS_TO_TARGET(Test ${GLOBAL_TEST_DEBUG_LINKER_FLAGS}) |
| INTERNAL_ADD_RELEASE_LINKER_FLAGS_TO_TARGET(Test ${GLOBAL_TEST_RELEASE_LINKER_FLAGS}) |
| |
| INTERNAL_ADD_DEBUG_DEFINITIONS_TO_TARGET(Test ${GLOBAL_TEST_DEBUG_DEFINITIONS}) |
| INTERNAL_ADD_RELEASE_DEFINITIONS_TO_TARGET(Test ${GLOBAL_TEST_RELEASE_DEFINITIONS}) |
| |
| INTERNAL_GROUP_LINK(GLOBAL_TEST_LIBS ${GLOBAL_TEST_LIBS}) |
| |
| TARGET_LINK_LIBRARIES(Test ${GLOBAL_TEST_LIBS} ${GoogleMock_LIBRARIES} ${GoogleTest_LIBRARIES} gtest_main gmock_main) |
| SET_TARGET_PROPERTIES(Test PROPERTIES LINKER_LANGUAGE CXX) |
| ENDIF() |
| ENDMACRO(INTERNAL_BUILD_UNIT_TESTS) |
| |
| |
| MACRO(INTERNAL_REQUIRED_PACKAGE pkg_name) |
| MESSAGE(STATUS "${CURRENT_MODULE_NAME} requires package ${pkg_name}") |
| |
| SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/modules") |
| |
| IF(NOT "${pkg_name}_FOUND" AND EXISTS "${CMAKE_MODULE_PATH}/Find${pkg_name}.cmake") |
| |
| find_package("${pkg_name}" REQUIRED) |
| |
| SET( ${pkg_name}}_FOUND "NO" ) |
| IF(DEFINED ${pkg_name}_INCLUDE_DIRS) |
| SET( ${pkg_name}_FOUND "YES" ) |
| |
| MARK_AS_ADVANCED( |
| ${pkg_name}_INCLUDE_DIRS |
| ${pkg_name}_LIBRARIES |
| ) |
| |
| ENDIF() |
| ENDIF() |
| |
| #INTERNAL_ADD_DEPENDENCY(${pkg_name}) |
| |
| IF("${pkg_name}_FOUND") |
| |
| INCLUDE_DIRECTORIES(${${pkg_name}_INCLUDE_DIRS}) |
| SET(${CURRENT_MODULE_NAME}_PACKAGE_LIBS ${${CURRENT_MODULE_NAME}_PACKAGE_LIBS} ${${pkg_name}_LIBRARIES}) |
| |
| # INTERNAL_ADD_DEFINITION("${${pkg_name}_DEPENDENT_DEFINITIONS}") |
| |
| ELSE() |
| MESSAGE(STATUS "WARNING: Required package '${pkg_name}' was not found.") |
| MESSAGE(STATUS "WARNING: Build of '${CURRENT_MODULE_NAME}' was disabled.") |
| MESSAGE(STATUS "WARNING: Install package '${pkg_name}' to enable build of '${CURRENT_MODULE_NAME}'.") |
| SET(${CURRENT_MODULE_NAME}_BUILD_ENABLED 0) |
| ENDIF() |
| |
| ENDMACRO(INTERNAL_REQUIRED_PACKAGE) |
| |
| |
| MACRO(INTERNAL_OPTIONAL_PACKAGE pkg_name) |
| MESSAGE(STATUS "${CURRENT_MODULE_NAME} optionally requires package ${pkg_name}") |
| |
| SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules/) |
| |
| find_package(${pkg_name} REQUIRED) |
| IF(${pkg_name}_FOUND) |
| INCLUDE_DIRECTORIES(${${pkg_name}_INCLUDE_DIR}) |
| SET(${CURRENT_MODULE_NAME}_PACKAGE_LIBS ${${CURRENT_MODULE_NAME}_PACKAGE_LIBS} ${${pkg_name}_LIBRARIES} CACHE INTERNAL "") |
| ELSE(${pkg_name}_FOUND) |
| MESSAGE(STATUS "INFO: Optional package '${pkg_name}' was not found.") |
| ENDIF(${pkg_name}_FOUND) |
| ENDMACRO(INTERNAL_OPTIONAL_PACKAGE) |
| |
| |
| MACRO(INTERNAL_INSTALL_HEADER_FILES ihf_header_file_path) |
| INSTALL(DIRECTORY ${PROJECT_SOURCE_DIR}/modules/${CURRENT_MODULE_NAME}/include/${CURRENT_MODULE_NAME}/ |
| DESTINATION ${ihf_header_file_path} |
| FILES_MATCHING |
| PATTERN ".*" EXCLUDE) |
| ENDMACRO(INTERNAL_INSTALL_HEADER_FILES) |
| |
| |
| MACRO(INTERNAL_INSTALL_MODULE) |
| |
| IF(${WITH_${CURRENT_UPPER_MODULE_NAME}} AND ${${CURRENT_MODULE_NAME}_BUILD_ENABLED}) |
| |
| INTERNAL_ARGUMENT_SPLITTER("${ARGN}" "HEADERS EXECUTABLE LIBRARY" INSTALL_PATH) |
| |
| IF(${INSTALL_PATH_HEADERS_FOUND}) |
| MESSAGE(STATUS "Install header files to ${INSTALL_PATH_HEADERS}") |
| INTERNAL_INSTALL_HEADER_FILES(${INSTALL_PATH_HEADERS}) |
| ENDIF(${INSTALL_PATH_HEADERS_FOUND}) |
| |
| IF(${INSTALL_PATH_EXECUTABLE_FOUND}) |
| MESSAGE(STATUS "Install executable files to ${INSTALL_PATH_EXECUTABLE}") |
| SET(INSTALL_COMMAND RUNTIME DESTINATION ${INSTALL_PATH_EXECUTABLE}) |
| ENDIF(${INSTALL_PATH_EXECUTABLE_FOUND}) |
| |
| IF(${INSTALL_PATH_LIBRARY_FOUND}) |
| MESSAGE(STATUS "Install library files to ${INSTALL_PATH_LIBRARY}") |
| SET(INSTALL_COMMAND ${INSTALL_COMMAND} LIBRARY DESTINATION ${INSTALL_PATH_LIBRARY}) |
| SET(INSTALL_COMMAND ${INSTALL_COMMAND} ARCHIVE DESTINATION ${INSTALL_PATH_LIBRARY}) |
| ENDIF(${INSTALL_PATH_LIBRARY_FOUND}) |
| |
| IF(NOT "${INSTALL_COMMAND}" STREQUAL "") |
| INSTALL(TARGETS ${CURRENT_MODULE_NAME} LIBRARY DESTINATION ${INSTALL_COMMAND}) |
| ENDIF(NOT "${INSTALL_COMMAND}" STREQUAL "") |
| |
| ENDIF() |
| |
| ENDMACRO(INTERNAL_INSTALL_MODULE) |
| |
| |
| MACRO(INTERNAL_INSTALL_RESOURCES) |
| IF(${WITH_${CURRENT_UPPER_MODULE_NAME}} AND ${${CURRENT_MODULE_NAME}_BUILD_ENABLED}) |
| INTERNAL_ARGUMENT_SPLITTER("${ARGN}" "FILES DESTINATION" RES) |
| MESSAGE(STATUS "install resource files to ${RES_DESTINATION}") |
| INSTALL(FILES ${RES_FILES} DESTINATION ${RES_DESTINATION}) |
| ENDIF() |
| ENDMACRO(INTERNAL_INSTALL_RESOURCES) |
| |
| MACRO(INTERNAL_LIST_TO_STRING ilts_input ilts_output) |
| STRING(REGEX REPLACE ";" " " ${ilts_output} "${ilts_input}") |
| ENDMACRO(INTERNAL_LIST_TO_STRING) |
| |
| MACRO(INTERNAL_ADD_EXTERNAL_LIBRARY ial_name) |
| INTERNAL_ARGUMENT_SPLITTER("${ARGN}" "INCLUDE_DIRS LIBRARY_DIRS LIBNAMES DEPENDENT_DEFINITIONS DEPENDENT_DEBUG_DEFINITIONS DEPENDENT_RELEASE_DEFINITIONS" IAL) |
| |
| SET(${ial_name}_INCLUDE_DIR "") |
| |
| FOREACH(ial_include_dir ${IAL_INCLUDE_DIRS}) |
| SET(${ial_name}_INCLUDE_DIR ${${ial_name}_INCLUDE_DIR} "${ial_include_dir}") |
| ENDFOREACH() |
| |
| SET(${ial_name}_LIBRARIES_DIR "") |
| FOREACH(ial_library_dir ${IAL_LIBRARY_DIRS}) |
| SET(${ial_name}_LIBRARIES_DIR ${${ial_name}_LIBRARIES_DIR} "${ial_library_dir}") |
| ENDFOREACH() |
| |
| SEPARATE_ARGUMENTS(IAL_LIBNAMES) |
| |
| SET(${ial_name}_LIBRARIES ${IAL_LIBNAMES}) |
| SET(${ial_name}_DEPENDENT_DEBUG_DEFINITIONS "${IAL_DEPENDENT_DEFINITIONS}" "${IAL_DEPENDENT_DEBUG_DEFINITIONS}") |
| SET(${ial_name}_DEPENDENT_RELEASE_DEFINITIONS "${IAL_DEPENDENT_DEFINITIONS}" "${IAL_DEPENDENT_RELEASE_DEFINITIONS}") |
| SET(${ial_name}_FOUND 1) |
| SET(${ial_name}_INTERNAL 1) |
| |
| MARK_AS_ADVANCED( |
| ${ial_name}_INCLUDE_DIR |
| ${ial_name}_LIBRARIES_DIR |
| ${ial_name}_LIBRARIES |
| ${ial_name}_DEPENDENT_DEBUG_DEFINITIONS |
| ${ial_name}_DEPENDENT_RELEASE_DEFINITIONS |
| ${ial_name}_FOUND |
| ${ial_name}_INTERNAL |
| ) |
| |
| #SET(GLOBAL_INCLUDE_DIRECTORIES ${GLOBAL_INCLUDE_DIRECTORIES} ${${ial_name}_INCLUDE_DIR} CACHE INTERNAL "collect include directories") |
| SET(GLOBAL_LIB_DIRECTORIES ${GLOBAL_LIB_DIRECTORIES} ${${ial_name}_LIBRARIES_DIR} CACHE INTERNAL "collect lib directories") |
| SET(GLOBAL_LIBRARIES ${GLOBAL_LIBRARIES} ${${ial_name}_LIBRARIES} CACHE INTERNAL "collect all linkable libraries") |
| |
| |
| #message("include dirs ${${ial_name}_INCLUDE_DIR}") |
| #message("library dirs ${${ial_name}_LIBRARIES_DIR}") |
| #message("libraries ${${ial_name}_LIBRARIES}") |
| #message("depandent defs ${${ial_name}_DEPENDENT_DEFINITIONS}") |
| |
| ENDMACRO(INTERNAL_ADD_EXTERNAL_LIBRARY) |
| |
| MACRO(INTERNAL_ADD_CMAKE_PROJECT iaap_name) |
| |
| INTERNAL_ARGUMENT_SPLITTER("${ARGN}" "LIBNAMES LIBDIRS INCLUDE_DIRS BINARY_INCLUDE_DIRS ABSOLUTE_INCLUDE_DIRS URL CHECKSUM SOURCE_DIR CMAKE_ARGUMENTS DEPENDENT_DEFINITIONS DEPENDENT_DEBUG_DEFINITIONS DEPENDENT_RELEASE_DEFINITIONS INSTALL CONFIG_FILE" IAAP) |
| |
| IF(NOT "${IAAP_URL}" STREQUAL "") |
| |
| SET(iaap_method DOWNLOAD_DIR "${THIRD_PARTY_DIR}/${iaap_name}" |
| URL "${IAAP_URL}" |
| URL_MD5 "${IAAP_CHECKSUM}") |
| |
| ELSEIF(NOT "${IAAP_SOURCE_DIR}" STREQUAL "") |
| |
| INTERNAL_LIST_TO_STRING("${IAAP_SOURCE_DIR}" IAAP_CONVERTED_SOURCE_DIR) |
| SET(IAAP_SOURCE_DIR "${IAAP_CONVERTED_SOURCE_DIR}") |
| SET(iaap_method SOURCE_DIR "${IAAP_SOURCE_DIR}" |
| DOWNLOAD_COMMAND "") |
| |
| ELSEIF(EXISTS "${THIRD_PARTY_DIR}/${iaap_name}") |
| |
| SET(IAAP_SOURCE_DIR "${THIRD_PARTY_DIR}/${iaap_name}") |
| SET(iaap_method SOURCE_DIR "${IAAP_SOURCE_DIR}" |
| DOWNLOAD_COMMAND "") |
| |
| ENDIF() |
| |
| IF(NOT "${iaap_method}" STREQUAL "") |
| |
| SET(BUILD_${iaap_name} 1 CACHE BOOL "Use ${iaap_name}") |
| |
| IF(${BUILD_${iaap_name}}) |
| |
| SET(ilts_cmake_arguments "") |
| FOREACH(ilts_cmake_argument ${IAAP_CMAKE_ARGUMENTS}) |
| SET(ilts_cmake_arguments ${ilts_cmake_arguments} -D${ilts_cmake_argument}) |
| ENDFOREACH() |
| |
| SET(ilts_install_command INSTALL_COMMAND "") |
| IF("${IAAP_INSTALL}" EQUAL 1) |
| SET(ilts_install_command "") |
| ENDIF() |
| |
| ExternalProject_Add( |
| ${iaap_name} |
| PREFIX ${CMAKE_BINARY_DIR}/${iaap_name} |
| ${iaap_method} |
| UPDATE_COMMAND "" |
| CMAKE_ARGS -DCMAKE_TOOLCHAIN_FILE:PATH=${CMAKE_TOOLCHAIN_FILE} |
| -DCMAKE_CXX_FLAGS_RELEASE:STRING=${CMAKE_CXX_FLAGS_RELEASE} |
| -DCMAKE_C_FLAGS_RELEASE:STRING=${CMAKE_C_FLAGS_RELEASE} |
| -DCMAKE_CXX_FLAGS_DEBUG:STRING=${CMAKE_CXX_FLAGS_DEBUG} |
| -DCMAKE_C_FLAGS_DEBUG:STRING=${CMAKE_C_FLAGS_DEBUG} |
| -DCMAKE_CXX_FLAGS:STRING=${CMAKE_CXX_FLAGS} |
| -DCMAKE_C_FLAGS:STRING=${CMAKE_C_FLAGS} |
| -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE} |
| -DBUILD_UNITTESTS:BOOLEAN=${BUILD_UNITTESTS} |
| -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${PROJECT_SOURCE_DIR}/deliverable/${iaap_name}/lib/${TARGET_OS}_${TARGET_ARCH} |
| -DCMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${PROJECT_SOURCE_DIR}/deliverable/${iaap_name}/lib/${TARGET_OS}_${TARGET_ARCH} |
| #-DCMAKE_ARCHIVE_OUTPUT_DIRECTORY:PATH=${THIRD_PARTY_DIR}/deliverable/${iaap_name}/lib/${TARGET_OS}_${TARGET_ARCH} |
| # -DCMAKE_LIBRARY_OUTPUT_DIRECTORY:PATH=${THIRD_PARTY_DIR}/deliverable/${iaap_name}/lib/${TARGET_OS}_${TARGET_ARCH} |
| # -DCMAKE_INSTALL_PREFIX=${THIRD_PARTY_DIR}/deliverable/${iaap_name} |
| -DCMAKE_INSTALL_PREFIX:PATH=${PROJECT_SOURCE_DIR}/deliverable/${iaap_name}/ |
| -DBUILD_GLOBAL_TEST_EXECUTABLE:BOOLEAN=${BUILD_GLOBAL_TEST_EXECUTABLE} |
| ${ilts_cmake_arguments} |
| "${ilts_install_command}" |
| ) |
| |
| # SET(${iaap_name}_DIR "${CMAKE_BINARY_DIR}/${iaap_name}") |
| SET(${iaap_name}_DIR "${IAAP_SOURCE_DIR}") |
| |
| SET(iacp_include_dirs "") |
| |
| IF(NOT ${IAAP_URL} STREQUAL "") |
| |
| foreach(iaap_include_dir ${IAAP_INCLUDE_DIRS}) |
| SET(iacp_include_dirs "${iacp_include_dirs}" "${CMAKE_BINARY_DIR}/${iaap_name}/${iaap_include_dir}") |
| endforeach() |
| |
| ELSE() |
| |
| foreach(iaap_include_dir ${IAAP_INCLUDE_DIRS}) |
| SET(iacp_include_dirs "${iacp_include_dirs}" "${PROJECT_SOURCE_DIR}/deliverable/${iaap_name}/include/${iaap_include_dir}") |
| #SET(${iaap_name}_INCLUDE_DIR "${${iaap_name}_INCLUDE_DIR}" "${CMAKE_INSTALL_PREFIX}/include/${iaap_include_dir}") |
| endforeach() |
| |
| foreach(iaap_include_dir ${IAAP_BINARY_INCLUDE_DIRS}) |
| SET(iacp_include_dirs "${iacp_include_dirs}" "${CMAKE_BINARY_DIR}/${iaap_name}/src/${iaap_name}-build/${iaap_include_dir}") |
| endforeach() |
| |
| foreach(iaap_include_dir ${IAAP_ABSOLUTE_INCLUDE_DIRS}) |
| SET(iacp_include_dirs "${iacp_include_dirs}" "${iaap_include_dir}") |
| endforeach() |
| |
| ENDIF() |
| |
| |
| INTERNAL_ADD_EXTERNAL_LIBRARY( ${iaap_name} |
| INCLUDE_DIRS "${iacp_include_dirs}" |
| LIBRARY_DIRS "${PROJECT_SOURCE_DIR}/deliverable/${iaap_name}/lib/${TARGET_OS}_${TARGET_ARCH}" ${IAAP_LIBDIRS} |
| LIBNAMES "${IAAP_LIBNAMES}" |
| DEPENDENT_DEFINITIONS "${IAAP_DEPENDENT_DEFINITIONS}" |
| DEPENDENT_DEBUG_DEFINITIONS "${IAAP_DEPENDENT_DEBUG_DEFINITIONS}" |
| DEPENDENT_RELEASE_DEFINITIONS "${IAAP_DEPENDENT_RELEASE_DEFINITIONS}") |
| ENDIF() |
| ENDIF() |
| |
| |
| ENDMACRO(INTERNAL_ADD_CMAKE_PROJECT) |
