Add patch function

Zerg1996 · Zerg1996 · commit dece09071bdc · 2018-06-24T22:20:30.000+03:00
diff --git a/share/modules/cmake/BCMConfig.cmake b/share/modules/cmake/BCMConfig.cmake
@@ -31,6 +31,8 @@ macro(cm_project INPUT_WORKSPACE_NAME INPUT_PROJECT_NAME)
     set(CURRENT_PROJECT_NAME ${INPUT_PROJECT_NAME})
     string(TOUPPER ${INPUT_PROJECT_NAME} UPPER_PROJECT_NAME)
     set(CURRENT_UPPER_PROJECT_NAME ${UPPER_PROJECT_NAME})
+    set_current_source_dir(${CMAKE_CURRENT_SOURCE_DIR} CURRENT_SOURCES_DIR)
+    set(CURRENT_TEST_SOURCES_DIR ${CURRENT_SOURCES_DIR}/test)
 endmacro()
 
 macro(cm_workspace WORKSPACE_NAME)
@@ -55,8 +57,12 @@ function(patch_file INPUT_SOURCE INPUT_PATCH OUTPUT_DIRECTORY)
     if(NOT Patch_FOUND)
         message(FATAL_ERROR "Patch utulity is not found")
     endif()
-
-    execute_process(COMMAND patch ${INPUT_SOURCE} ${INPUT_PATCH}
+    string(REPLACE ${CURRENT_TEST_SOURCES_DIR} ${CMAKE_CURRENT_BINARY_DIR} OUTPUT_FILE ${INPUT_SOURCE})
+    get_filename_component(OUTPUT_DIRECTORY ${OUTPUT_FILE} DIRECTORY)
+    message(COPY ${INPUT_SOURCE} DESTINATION ${OUTPUT_DIRECTORY})
+    file(COPY ${INPUT_SOURCE} DESTINATION ${OUTPUT_DIRECTORY})
+    get_filename_component(SOURCE_FILE_NAME ${INPUT_SOURCE} NAME)
+    execute_process(COMMAND patch ${OUTPUT_FILE} ${INPUT_PATCH}
                     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 endfunction()
 
@@ -65,13 +71,27 @@ function(patch_directory SOURCES_DIRECTORY PATCHES_DIRECTORY OUTPUT_DIRECTORY)
     if(NOT Patch_FOUND)
         message(FATAL_ERROR "Patch utulity is not found")
     endif()
+    file(GLOB_RECURSE PATCHES_FILES LIST_DIRECTORIES FALSE ${PATCHES_DIRECTORY}/*.patch)
+    file(GLOB_RECURSE SOURCES_FILES LIST_DIRECTORIES FALSE ${SOURCES_DIRECTORY}/*)
+    message(PTCH = ${PATCHES_DIRECTORY})
+    message(SRC = ${SOURCES_DIRECTORY})
+    foreach(PATCH_FILE IN LISTS PATCHES_FILES)
+        #get_filename_component(PATHC_FILE_NAME ${PATCH_FILE} NAME)
+        #message("SOURCES_DIRECTORY=" ${SOURCES_DIRECTORY})
+        #message("PATHC_FILE_NAME=" ${PATCHES_DIRECTORY})
+        string(REPLACE ".patch" "" SOURCE_FILE_NAME ${PATCH_FILE})
+        string(REPLACE ${PATCHES_DIRECTORY} ${SOURCES_DIRECTORY} SOURCE_FILE_NAME ${SOURCE_FILE_NAME})
 
-    file(GLOB_RECURSE ${PATCHES_FILES} LIST_DIRECTORIES FALSE ${PATCHES_DIRECTORY})
-    file(GLOB_RECURSE ${SOURCES_FILES} LIST_DIRECTORIES FALSE ${SOURCES_DIRECTORY})
-
-    foreach(PATCH_FILE IN PATCHES_FILES)
-        string(REPLACE ".patch" ${PATCH_FILE} PATCH_FILE_NAME)
-        list(FIND ${SOURCES_FILES} PATCH_FILE)
-        execute_process(COMMAND patch)
+        list(FIND SOURCES_FILES ${SOURCE_FILE_NAME} SOURCES_FILE_FIND)
+        if (${SOURCES_FILE_FIND} EQUAL -1)
+            message(FATAL_ERROR "Source file for patch is not found: " ${PATCH_FILE})
+        endif()
+        list(GET SOURCES_FILES ${SOURCES_FILE_FIND} SOURCE_FILE)
+        patch_file(${SOURCE_FILE} ${PATCH_FILE} ${OUTPUT_DIRECTORY})
     endforeach()
+endfunction()
+
+function(set_current_source_dir WORKSPACE_SOURCE RESULT_NAME)
+    string(REPLACE "/libs" "/boost_1.58/libs" CURRENT_SOURCES_DIR ${WORKSPACE_SOURCE})
+    set(${RESULT_NAME} ${CURRENT_SOURCES_DIR} PARENT_SCOPE)
 endfunction()
diff --git a/share/modules/cmake/BCMTest.cmake b/share/modules/cmake/BCMTest.cmake
@@ -2,93 +2,93 @@ option(BUILD_TESTS "Controls whether to build the tests as part of the main buil
 
 enable_testing()
 
-foreach(scope GLOBAL DIRECTORY)
+foreach (scope GLOBAL DIRECTORY)
     define_property(${scope} PROPERTY "ENABLE_TESTS" INHERITED
-                    BRIEF_DOCS "Enable tests"
-                    FULL_DOCS "Enable tests"
-                    )
-endforeach()
+            BRIEF_DOCS "Enable tests"
+            FULL_DOCS "Enable tests"
+            )
+endforeach ()
 option(CMAKE_ENABLE_TESTS "Enable tests" ON)
 set_property(GLOBAL PROPERTY ENABLE_TESTS ${CMAKE_ENABLE_TESTS})
 
 include(ProcessorCount)
 processorcount(_cm_ctest_parallel_level)
 set(CTEST_PARALLEL_LEVEL ${_cm_ctest_parallel_level} CACHE STRING "CTest parallel level")
 
-if(NOT TARGET check)
+if (NOT TARGET check)
     add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C ${CMAKE_CFG_INTDIR} -j ${CTEST_PARALLEL_LEVEL} WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
-endif()
+endif ()
 
 
-if(NOT TARGET tests)
+if (NOT TARGET tests)
     add_custom_target(tests COMMENT "Build all tests.")
     add_dependencies(check tests)
-endif()
+endif ()
 
-if(NOT TARGET check-${PROJECT_NAME})
+if (NOT TARGET check-${PROJECT_NAME})
     add_custom_target(check-${PROJECT_NAME} COMMAND ${CMAKE_CTEST_COMMAND} -L ${PROJECT_NAME} --output-on-failure -C ${CMAKE_CFG_INTDIR} -j ${CTEST_PARALLEL_LEVEL} WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
-endif()
+endif ()
 
-if(NOT TARGET tests-${PROJECT_NAME})
+if (NOT TARGET tests-${PROJECT_NAME})
     add_custom_target(tests-${PROJECT_NAME} COMMENT "Build all tests for ${PROJECT_NAME}.")
     add_dependencies(check-${PROJECT_NAME} tests-${PROJECT_NAME})
-endif()
+endif ()
 
 function(cm_mark_as_test)
-    foreach(TEST_TARGET ${ARGN})
-        if(NOT BUILD_TESTS)
+    foreach (TEST_TARGET ${ARGN})
+        if (NOT BUILD_TESTS)
             get_target_property(TEST_TARGET_TYPE ${TEST_TARGET} TYPE)
             # We can onle use EXCLUDE_FROM_ALL on build targets
-            if(NOT "${TEST_TARGET_TYPE}" STREQUAL "INTERFACE_LIBRARY")
+            if (NOT "${TEST_TARGET_TYPE}" STREQUAL "INTERFACE_LIBRARY")
                 set_target_properties(${TEST_TARGET}
-                                      PROPERTIES EXCLUDE_FROM_ALL TRUE
-                                      )
-            endif()
-        endif()
+                        PROPERTIES EXCLUDE_FROM_ALL TRUE
+                        )
+            endif ()
+        endif ()
         add_dependencies(tests ${TEST_TARGET})
         add_dependencies(tests-${PROJECT_NAME} ${TEST_TARGET})
-    endforeach()
+    endforeach ()
 endfunction(cm_mark_as_test)
 
 
 function(cm_create_internal_targets)
-    if(NOT TARGET _cm_internal_tests-${PROJECT_NAME})
+    if (NOT TARGET _cm_internal_tests-${PROJECT_NAME})
         file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/_cm_internal_tests-${PROJECT_NAME}.cpp "")
         add_library(_cm_internal_tests-${PROJECT_NAME} STATIC ${CMAKE_CURRENT_BINARY_DIR}/_cm_internal_tests-${PROJECT_NAME}.cpp)
         cm_mark_as_test(_cm_internal_tests-${PROJECT_NAME})
-    endif()
+    endif ()
 endfunction()
 
-foreach(scope DIRECTORY TARGET)
+foreach (scope DIRECTORY TARGET)
     define_property(${scope} PROPERTY "BCM_TEST_DEPENDENCIES" INHERITED
-                    BRIEF_DOCS "Default test dependencies"
-                    FULL_DOCS "Default test dependencies"
-                    )
-endforeach()
+            BRIEF_DOCS "Default test dependencies"
+            FULL_DOCS "Default test dependencies"
+            )
+endforeach ()
 
 function(cm_test_link_libraries)
     cm_create_internal_targets()
-    if(BUILD_TESTS)
+    if (BUILD_TESTS)
         set_property(DIRECTORY APPEND PROPERTY BCM_TEST_DEPENDENCIES ${ARGN})
         target_link_libraries(_cm_internal_tests-${PROJECT_NAME} ${ARGN})
-    else()
-        foreach(TARGET ${ARGN})
-            if(TARGET ${TARGET})
+    else ()
+        foreach (TARGET ${ARGN})
+            if (TARGET ${TARGET})
                 set_property(DIRECTORY APPEND PROPERTY BCM_TEST_DEPENDENCIES ${TARGET})
                 target_link_libraries(_cm_internal_tests-${PROJECT_NAME} ${TARGET})
-            elseif(${TARGET} MATCHES "::")
+            elseif (${TARGET} MATCHES "::")
                 cm_shadow_exists(HAS_TARGET ${TARGET})
                 set_property(DIRECTORY APPEND PROPERTY BCM_TEST_DEPENDENCIES $<${HAS_TARGET}:${TARGET}>)
                 target_link_libraries(_cm_internal_tests-${PROJECT_NAME} $<${HAS_TARGET}:${TARGET}>)
-            else()
+            else ()
                 set_property(DIRECTORY APPEND PROPERTY BCM_TEST_DEPENDENCIES ${TARGET})
                 target_link_libraries(_cm_internal_tests-${PROJECT_NAME} ${TARGET})
-            endif()
-            if(BUILD_SHARED_LIBS)
+            endif ()
+            if (BUILD_SHARED_LIBS)
                 target_compile_definitions(_cm_internal_tests-${PROJECT_NAME} PRIVATE -DBOOST_TEST_DYN_LINK=1 -DBOOST_TEST_NO_AUTO_LINK=1)
-            endif()
-        endforeach()
-    endif()
+            endif ()
+        endforeach ()
+    endif ()
 endfunction()
 
 function(cm_target_link_test_libs TARGET)
@@ -102,42 +102,50 @@ endfunction()
 
 function(cm_test)
     set(options COMPILE_ONLY WILL_FAIL NO_TEST_LIBS)
-    set(oneValueArgs NAME)
+    set(oneValueArgs NAME SOURCES_PREFIX)
     set(multiValueArgs SOURCES CONTENT ARGS)
 
     cmake_parse_arguments(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    if(PARSE_UNPARSED_ARGUMENTS)
+    if (PARSE_UNPARSED_ARGUMENTS)
         message(FATAL_ERROR "Unknown keywords given to cm_test(): \"${PARSE_UNPARSED_ARGUMENTS}\"")
-    endif()
+    endif ()
 
     set(SOURCES ${PARSE_SOURCES})
 
-    if(PARSE_NAME)
+    if (PARSE_NAME)
         set(TEST_NAME ${PARSE_NAME})
-    else()
+    else ()
         string(MAKE_C_IDENTIFIER "${PROJECT_NAME}_${SOURCES}_test" TEST_NAME)
-    endif()
+    endif ()
 
-    if(PARSE_CONTENT)
+    if (PARSE_CONTENT)
         file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/generated-${TEST_NAME}.cpp "${PARSE_CONTENT}")
         set(SOURCES ${CMAKE_CURRENT_BINARY_DIR}/generated-${TEST_NAME}.cpp)
-    endif()
+    endif ()
 
-    if(PARSE_COMPILE_ONLY)
+    if (PARSE_COMPILE_ONLY)
         add_library(${TEST_NAME} STATIC EXCLUDE_FROM_ALL ${SOURCES})
         add_test(NAME ${TEST_NAME}
-                 COMMAND ${CMAKE_COMMAND} --build . --target ${TEST_NAME} --config $<CONFIGURATION>
-                 WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
-        target_include_directories(${TEST_NAME} PRIVATE ${CMAKE_CURRENT_LIST_DIR})
+                COMMAND ${CMAKE_COMMAND} --build . --target ${TEST_NAME} --config $<CONFIGURATION>
+                WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+        if (PARSE_SOURCES_PREFIX)
+            target_include_directories(${TEST_NAME} PRIVATE ${PARSE_SOURCES_PREFIX})
+        else ()
+            target_include_directories(${TEST_NAME} PRIVATE ${CMAKE_CURRENT_LIST_DIR})
+        endif ()
 
         # set_tests_properties(${TEST_NAME} PROPERTIES RESOURCE_LOCK cm_test_compile_only)
-    else()
+    else ()
         add_executable(${TEST_NAME} ${SOURCES})
         cm_mark_as_test(${TEST_NAME})
-        target_include_directories(${TEST_NAME} PRIVATE ${CMAKE_CURRENT_LIST_DIR})
-        if(WIN32)
-            foreach(CONFIG ${CMAKE_CONFIGURATION_TYPES} "")
+        if (PARSE_SOURCES_PREFIX)
+            target_include_directories(${TEST_NAME} PRIVATE ${PARSE_SOURCES_PREFIX})
+        else ()
+            target_include_directories(${TEST_NAME} PRIVATE ${CMAKE_CURRENT_LIST_DIR})
+        endif ()
+        if (WIN32)
+            foreach (CONFIG ${CMAKE_CONFIGURATION_TYPES} "")
                 file(GENERATE OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${TEST_NAME}-test-run-${CONFIG}.cmake CONTENT "
 include(\"${CMAKE_BINARY_DIR}/cm_set_rpath-$<CONFIG>.cmake\")
 if(CMAKE_CROSSCOMPILING)
@@ -157,24 +165,24 @@ if(NOT RESULT EQUAL 0)
     message(FATAL_ERROR \"Test failed\")
 endif()
 " CONDITION $<CONFIG:${CONFIG}>)
-            endforeach()
+            endforeach ()
             add_test(NAME ${TEST_NAME} COMMAND ${CMAKE_COMMAND} -DCMAKE_CROSSCOMPILING=${CMAKE_CROSSCOMPILING} -P ${CMAKE_CURRENT_BINARY_DIR}/${TEST_NAME}-test-run-$<CONFIG>.cmake)
-        else()
+        else ()
             add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME} ${PARSE_ARGS} WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-        endif()
-    endif()
+        endif ()
+    endif ()
 
-    if(BUILD_SHARED_LIBS)
+    if (BUILD_SHARED_LIBS)
         target_compile_definitions(${TEST_NAME} PRIVATE -DBOOST_TEST_DYN_LINK=1 -DBOOST_TEST_NO_AUTO_LINK=1)
-    endif()
+    endif ()
 
-    if(PARSE_WILL_FAIL)
+    if (PARSE_WILL_FAIL)
         set_tests_properties(${TEST_NAME} PROPERTIES WILL_FAIL TRUE)
-    endif()
+    endif ()
     set_tests_properties(${TEST_NAME} PROPERTIES LABELS ${PROJECT_NAME})
-    if(NOT PARSE_NO_TEST_LIBS)
+    if (NOT PARSE_NO_TEST_LIBS)
         cm_target_link_test_libs(${TEST_NAME})
-    endif()
+    endif ()
 endfunction(cm_test)
 
 function(cm_test_header)
@@ -184,40 +192,41 @@ function(cm_test_header)
 
     cmake_parse_arguments(PARSE "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
 
-    if(PARSE_UNPARSED_ARGUMENTS)
+    if (PARSE_UNPARSED_ARGUMENTS)
         message(FATAL_ERROR "Unknown keywords given to cm_test_header(): \"${PARSE_UNPARSED_ARGUMENTS}\"")
-    endif()
+    endif ()
 
-    if(PARSE_NAME)
+    if (PARSE_NAME)
         set(TEST_NAME ${PARSE_NAME})
-    else()
+    else ()
         string(MAKE_C_IDENTIFIER "${PROJECT_NAME}_${PARSE_HEADER}_header_test" TEST_NAME)
-    endif()
+    endif ()
 
-    if(PARSE_STATIC)
+    if (PARSE_STATIC)
         file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/header-main-include-${TEST_NAME}.cpp
-             "#include <${PARSE_HEADER}>\nint main() {}\n"
-             )
+                "#include <${PARSE_HEADER}>\nint main() {}\n"
+                )
         file(WRITE ${CMAKE_CURRENT_BINARY_DIR}/header-static-include-${TEST_NAME}.cpp
-             "#include <${PARSE_HEADER}>\n"
-             )
+                "#include <${PARSE_HEADER}>\n"
+                )
         cm_test(NAME ${TEST_NAME} SOURCES
-                 ${CMAKE_CURRENT_BINARY_DIR}/header-main-include-${TEST_NAME}.cpp
-                 ${CMAKE_CURRENT_BINARY_DIR}/header-static-include-${TEST_NAME}.cpp
-                 )
-    else()
+                ${CMAKE_CURRENT_BINARY_DIR}/header-main-include-${TEST_NAME}.cpp
+                ${CMAKE_CURRENT_BINARY_DIR}/header-static-include-${TEST_NAME}.cpp
+                )
+    else ()
         cm_test(NAME ${TEST_NAME} CONTENT
-                 "#include <${PARSE_HEADER}>\nint main() {}\n"
-                 )
-    endif()
+                "#include <${PARSE_HEADER}>\nint main() {}\n"
+                )
+    endif ()
     set_tests_properties(${TEST_NAME} PROPERTIES LABELS ${PROJECT_NAME})
 endfunction(cm_test_header)
 
 macro(cm_add_test_subdirectory)
     get_directory_property(_enable_tests_property ENABLE_TESTS)
     get_property(_enable_tests_global_property GLOBAL PROPERTY ENABLE_TESTS)
     string(TOUPPER "${_enable_tests_property}" _enable_tests_property_upper)
-    if(_enable_tests_property_upper STREQUAL "OFF" OR _enable_tests_property_upper EQUAL 1)
+    if (_enable_tests_property_upper STREQUAL "OFF" OR _enable_tests_property_upper EQUAL 1)
+        set(CURRENT_SOURCES_DIR ${CURRENT_SOURCES_DIR}/test)
         add_subdirectory(${ARGN})
-    endif()
+    endif ()
 endmacro()
