528 lines
21 KiB
CMake
528 lines
21 KiB
CMake
# This file is for macros that are used by multiple projects. If your macro is
|
|
# exclusively needed in only one subdirectory of Source (e.g. only needed by
|
|
# WebCore), then put it there instead.
|
|
|
|
macro(WEBKIT_COMPUTE_SOURCES _framework)
|
|
set(_derivedSourcesPath ${${_framework}_DERIVED_SOURCES_DIR})
|
|
|
|
foreach (_sourcesListFile IN LISTS ${_framework}_UNIFIED_SOURCE_LIST_FILES)
|
|
configure_file("${CMAKE_CURRENT_SOURCE_DIR}/${_sourcesListFile}" "${_derivedSourcesPath}/${_sourcesListFile}" COPYONLY)
|
|
message(STATUS "Using source list file: ${_sourcesListFile}")
|
|
|
|
list(APPEND _sourceListFileTruePaths "${CMAKE_CURRENT_SOURCE_DIR}/${_sourcesListFile}")
|
|
endforeach ()
|
|
|
|
if (ENABLE_UNIFIED_BUILDS)
|
|
execute_process(COMMAND ${RUBY_EXECUTABLE} ${WTF_SCRIPTS_DIR}/generate-unified-source-bundles.rb
|
|
"--derived-sources-path" "${_derivedSourcesPath}"
|
|
"--source-tree-path" ${CMAKE_CURRENT_SOURCE_DIR}
|
|
"--print-bundled-sources"
|
|
${_sourceListFileTruePaths}
|
|
RESULT_VARIABLE _resultTmp
|
|
OUTPUT_VARIABLE _outputTmp)
|
|
|
|
if (${_resultTmp})
|
|
message(FATAL_ERROR "generate-unified-source-bundles.rb exited with non-zero status, exiting")
|
|
endif ()
|
|
|
|
foreach (_sourceFileTmp IN LISTS _outputTmp)
|
|
set_source_files_properties(${_sourceFileTmp} PROPERTIES HEADER_FILE_ONLY ON)
|
|
list(APPEND ${_framework}_HEADERS ${_sourceFileTmp})
|
|
endforeach ()
|
|
unset(_sourceFileTmp)
|
|
|
|
execute_process(COMMAND ${RUBY_EXECUTABLE} ${WTF_SCRIPTS_DIR}/generate-unified-source-bundles.rb
|
|
"--derived-sources-path" "${_derivedSourcesPath}"
|
|
"--source-tree-path" ${CMAKE_CURRENT_SOURCE_DIR}
|
|
${_sourceListFileTruePaths}
|
|
RESULT_VARIABLE _resultTmp
|
|
OUTPUT_VARIABLE _outputTmp)
|
|
|
|
if (${_resultTmp})
|
|
message(FATAL_ERROR "generate-unified-source-bundles.rb exited with non-zero status, exiting")
|
|
endif ()
|
|
|
|
list(APPEND ${_framework}_SOURCES ${_outputTmp})
|
|
unset(_resultTmp)
|
|
unset(_outputTmp)
|
|
else ()
|
|
execute_process(COMMAND ${RUBY_EXECUTABLE} ${WTF_SCRIPTS_DIR}/generate-unified-source-bundles.rb
|
|
"--derived-sources-path" "${_derivedSourcesPath}"
|
|
"--source-tree-path" ${CMAKE_CURRENT_SOURCE_DIR}
|
|
"--print-all-sources"
|
|
${_sourceListFileTruePaths}
|
|
RESULT_VARIABLE _resultTmp
|
|
OUTPUT_VARIABLE _outputTmp)
|
|
|
|
if (${_resultTmp})
|
|
message(FATAL_ERROR "generate-unified-source-bundles.rb exited with non-zero status, exiting")
|
|
endif ()
|
|
|
|
list(APPEND ${_framework}_SOURCES ${_outputTmp})
|
|
unset(_resultTmp)
|
|
unset(_outputTmp)
|
|
endif ()
|
|
endmacro()
|
|
|
|
macro(WEBKIT_INCLUDE_CONFIG_FILES_IF_EXISTS)
|
|
set(_file ${CMAKE_CURRENT_SOURCE_DIR}/Platform${PORT}.cmake)
|
|
if (EXISTS ${_file})
|
|
message(STATUS "Using platform-specific CMakeLists: ${_file}")
|
|
include(${_file})
|
|
else ()
|
|
message(STATUS "Platform-specific CMakeLists not found: ${_file}")
|
|
endif ()
|
|
endmacro()
|
|
|
|
# Append the given dependencies to the source file
|
|
macro(WEBKIT_ADD_SOURCE_DEPENDENCIES _source _deps)
|
|
set(_tmp)
|
|
get_source_file_property(_tmp ${_source} OBJECT_DEPENDS)
|
|
if (NOT _tmp)
|
|
set(_tmp "")
|
|
endif ()
|
|
|
|
foreach (f ${_deps})
|
|
list(APPEND _tmp "${f}")
|
|
endforeach ()
|
|
|
|
set_source_files_properties(${_source} PROPERTIES OBJECT_DEPENDS "${_tmp}")
|
|
unset(_tmp)
|
|
endmacro()
|
|
|
|
macro(WEBKIT_ADD_PRECOMPILED_HEADER _header _cpp _source)
|
|
if (MSVC)
|
|
get_filename_component(PrecompiledBasename ${_cpp} NAME_WE)
|
|
file(MAKE_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/${_source}")
|
|
set(PrecompiledBinary "${CMAKE_CURRENT_BINARY_DIR}/${_source}/${PrecompiledBasename}.pch")
|
|
set(_sources ${${_source}})
|
|
|
|
# clang-cl requires /FI with /Yc
|
|
if (COMPILER_IS_CLANG_CL)
|
|
set_source_files_properties(${_cpp}
|
|
PROPERTIES COMPILE_FLAGS "/Yc\"${_header}\" /Fp\"${PrecompiledBinary}\" /FI\"${_header}\""
|
|
OBJECT_OUTPUTS "${PrecompiledBinary}")
|
|
else ()
|
|
set_source_files_properties(${_cpp}
|
|
PROPERTIES COMPILE_FLAGS "/Yc\"${_header}\" /Fp\"${PrecompiledBinary}\""
|
|
OBJECT_OUTPUTS "${PrecompiledBinary}")
|
|
endif ()
|
|
set_source_files_properties(${_sources}
|
|
PROPERTIES COMPILE_FLAGS "/Yu\"${_header}\" /FI\"${_header}\" /Fp\"${PrecompiledBinary}\"")
|
|
|
|
foreach (_src ${_sources})
|
|
WEBKIT_ADD_SOURCE_DEPENDENCIES(${_src} ${PrecompiledBinary})
|
|
endforeach ()
|
|
|
|
list(APPEND ${_source} ${_cpp})
|
|
endif ()
|
|
#FIXME: Add support for Xcode.
|
|
endmacro()
|
|
|
|
macro(WEBKIT_FRAMEWORK_DECLARE _target)
|
|
# add_library() without any source files triggers CMake warning
|
|
# Addition of dummy "source" file does not result in any changes in generated build.ninja file
|
|
add_library(${_target} ${${_target}_LIBRARY_TYPE} "${CMAKE_BINARY_DIR}/cmakeconfig.h")
|
|
endmacro()
|
|
|
|
macro(WEBKIT_EXECUTABLE_DECLARE _target)
|
|
add_executable(${_target} "${CMAKE_BINARY_DIR}/cmakeconfig.h")
|
|
endmacro()
|
|
|
|
# Private macro for setting the properties of a target.
|
|
# Rather than just having _target like WEBKIT_FRAMEWORK and WEBKIT_EXECUTABLE the parameters are
|
|
# split into _target_logical_name, which is used for variable expansion, and _target_cmake_name.
|
|
# This is done to support WEBKIT_WRAP_EXECUTABLE which uses the _target_logical_name variables
|
|
# but requires a different _target_cmake_name.
|
|
macro(_WEBKIT_TARGET _target_logical_name _target_cmake_name)
|
|
target_sources(${_target_cmake_name} PRIVATE
|
|
${${_target_logical_name}_HEADERS}
|
|
${${_target_logical_name}_SOURCES}
|
|
)
|
|
target_include_directories(${_target_cmake_name} PUBLIC "$<BUILD_INTERFACE:${${_target_logical_name}_INCLUDE_DIRECTORIES}>")
|
|
target_include_directories(${_target_cmake_name} SYSTEM PRIVATE "$<BUILD_INTERFACE:${${_target_logical_name}_SYSTEM_INCLUDE_DIRECTORIES}>")
|
|
target_include_directories(${_target_cmake_name} PRIVATE "$<BUILD_INTERFACE:${${_target_logical_name}_PRIVATE_INCLUDE_DIRECTORIES}>")
|
|
foreach(inc ${${_target}_LOCAL_INCLUDE_DIRECTORIES})
|
|
add_definitions(-iquote ${inc})
|
|
endforeach()
|
|
|
|
target_compile_definitions(${_target_cmake_name} PRIVATE "BUILDING_${_target_logical_name}")
|
|
if (${_target_logical_name}_DEFINITIONS)
|
|
target_compile_definitions(${_target_cmake_name} PUBLIC ${${_target_logical_name}_DEFINITIONS})
|
|
endif ()
|
|
if (${_target_logical_name}_PRIVATE_DEFINITIONS)
|
|
target_compile_definitions(${_target_cmake_name} PRIVATE ${${_target_logical_name}_PRIVATE_DEFINITIONS})
|
|
endif ()
|
|
|
|
if (${_target_logical_name}_LIBRARIES)
|
|
target_link_libraries(${_target_cmake_name} PUBLIC ${${_target_logical_name}_LIBRARIES})
|
|
endif ()
|
|
if (${_target_logical_name}_PRIVATE_LIBRARIES)
|
|
target_link_libraries(${_target_cmake_name} PRIVATE ${${_target_logical_name}_PRIVATE_LIBRARIES})
|
|
endif ()
|
|
|
|
if (${_target_logical_name}_DEPENDENCIES)
|
|
add_dependencies(${_target_cmake_name} ${${_target_logical_name}_DEPENDENCIES})
|
|
endif ()
|
|
endmacro()
|
|
|
|
macro(_WEBKIT_TARGET_ANALYZE _target)
|
|
if (ClangTidy_EXE)
|
|
set(_clang_path_and_options
|
|
${ClangTidy_EXE}
|
|
# Include all non system headers
|
|
--header-filter=.*
|
|
)
|
|
set_target_properties(${_target} PROPERTIES
|
|
C_CLANG_TIDY "${_clang_path_and_options}"
|
|
CXX_CLANG_TIDY "${_clang_path_and_options}"
|
|
)
|
|
endif ()
|
|
|
|
if (IWYU_EXE)
|
|
set(_iwyu_path_and_options
|
|
${IWYU_EXE}
|
|
# Suggests the more concise syntax introduced in C++17
|
|
-Xiwyu --cxx17ns
|
|
# Tells iwyu to always keep these includes
|
|
-Xiwyu --keep=**/config.h
|
|
)
|
|
if (MSVC)
|
|
list(APPEND _iwyu_path_and_options --driver-mode=cl)
|
|
endif ()
|
|
set_target_properties(${_target} PROPERTIES
|
|
CXX_INCLUDE_WHAT_YOU_USE "${_iwyu_path_and_options}"
|
|
)
|
|
endif ()
|
|
endmacro()
|
|
|
|
function(_WEBKIT_LINK_FRAMEWORK_INTO target_name framework _public_frameworks_var _private_frameworks_var)
|
|
set_property(GLOBAL PROPERTY ${framework}_LINKED_INTO ${target_name})
|
|
|
|
get_property(_framework_public_frameworks GLOBAL PROPERTY ${framework}_FRAMEWORKS)
|
|
foreach (dependency IN LISTS ${_framework_public_frameworks})
|
|
set(${_public_frameworks_var} "${${_public_frameworks_var}};${dependency}" PARENT_SCOPE)
|
|
endforeach ()
|
|
|
|
get_property(_framework_private_frameworks GLOBAL PROPERTY ${framework}_PRIVATE_FRAMEWORKS)
|
|
foreach (dependency IN LISTS _framework_private_frameworks)
|
|
set(${_private_frameworks_var} "${${_private_frameworks_var}};${dependency}" PARENT_SCOPE)
|
|
_WEBKIT_LINK_FRAMEWORK_INTO(${target_name} ${dependency} ${_public_frameworks_var} ${_private_frameworks_var})
|
|
endforeach ()
|
|
endfunction()
|
|
|
|
macro(_WEBKIT_FRAMEWORK_LINK_FRAMEWORK _target_name)
|
|
# Set the public libraries before modifying them when determining visibility.
|
|
set_property(GLOBAL PROPERTY ${_target_name}_PUBLIC_LIBRARIES ${${_target_name}_LIBRARIES})
|
|
|
|
set(_public_frameworks)
|
|
set(_private_frameworks)
|
|
|
|
foreach (framework IN LISTS ${_target_name}_FRAMEWORKS)
|
|
get_property(_linked_into GLOBAL PROPERTY ${framework}_LINKED_INTO)
|
|
if (_linked_into)
|
|
list(APPEND _public_frameworks ${_linked_into})
|
|
elseif (${framework}_LIBRARY_TYPE STREQUAL "SHARED")
|
|
list(APPEND _public_frameworks ${framework})
|
|
else ()
|
|
list(APPEND _private_frameworks ${framework})
|
|
endif ()
|
|
endforeach ()
|
|
|
|
# Recurse into the dependent frameworks
|
|
if (_private_frameworks)
|
|
list(REMOVE_DUPLICATES _private_frameworks)
|
|
endif ()
|
|
if (${_target_name}_LIBRARY_TYPE STREQUAL "SHARED")
|
|
set_property(GLOBAL PROPERTY ${_target_name}_LINKED_INTO ${_target_name})
|
|
foreach (framework IN LISTS _private_frameworks)
|
|
_WEBKIT_LINK_FRAMEWORK_INTO(${_target_name} ${framework} _public_frameworks _private_frameworks)
|
|
endforeach ()
|
|
endif ()
|
|
|
|
# Add to the ${target_name}_LIBRARIES
|
|
if (_public_frameworks)
|
|
list(REMOVE_DUPLICATES _public_frameworks)
|
|
endif ()
|
|
foreach (framework IN LISTS _public_frameworks)
|
|
list(APPEND ${_target_name}_LIBRARIES WebKit::${framework})
|
|
endforeach ()
|
|
|
|
# Add to the ${target_name}_PRIVATE_LIBRARIES
|
|
if (_private_frameworks)
|
|
list(REMOVE_DUPLICATES _private_frameworks)
|
|
endif ()
|
|
foreach (framework IN LISTS _private_frameworks)
|
|
if (${_target_name}_LIBRARY_TYPE STREQUAL "SHARED")
|
|
get_property(_linked_libraries GLOBAL PROPERTY ${framework}_PUBLIC_LIBRARIES)
|
|
list(APPEND ${_target_name}_INTERFACE_LIBRARIES
|
|
${_linked_libraries}
|
|
)
|
|
list(APPEND ${_target_name}_INTERFACE_INCLUDE_DIRECTORIES
|
|
${${framework}_FRAMEWORK_HEADERS_DIR}
|
|
${${framework}_PRIVATE_FRAMEWORK_HEADERS_DIR}
|
|
)
|
|
list(APPEND ${_target_name}_PRIVATE_LIBRARIES WebKit::${framework})
|
|
if (${framework}_LIBRARY_TYPE STREQUAL "OBJECT")
|
|
list(APPEND ${_target_name}_PRIVATE_LIBRARIES $<TARGET_OBJECTS:${framework}>)
|
|
endif ()
|
|
else ()
|
|
list(APPEND ${_target_name}_LIBRARIES WebKit::${framework})
|
|
endif ()
|
|
endforeach ()
|
|
|
|
set_property(GLOBAL PROPERTY ${_target_name}_FRAMEWORKS ${_public_frameworks})
|
|
set_property(GLOBAL PROPERTY ${_target_name}_PRIVATE_FRAMEWORKS ${_private_frameworks})
|
|
endmacro()
|
|
|
|
macro(_WEBKIT_EXECUTABLE_LINK_FRAMEWORK _target)
|
|
foreach (framework IN LISTS ${_target}_FRAMEWORKS)
|
|
get_property(_linked_into GLOBAL PROPERTY ${framework}_LINKED_INTO)
|
|
|
|
# See if the executable is linking a framework that the specified framework is already linked into
|
|
if ((NOT _linked_into) OR (${framework} STREQUAL ${_linked_into}) OR (NOT ${_linked_into} IN_LIST ${_target}_FRAMEWORKS))
|
|
list(APPEND ${_target}_PRIVATE_LIBRARIES WebKit::${framework})
|
|
|
|
# The WebKit:: alias targets do not propagate OBJECT libraries so the
|
|
# underyling library's objects are explicitly added to link properly
|
|
if (TARGET ${framework} AND ${framework}_LIBRARY_TYPE STREQUAL "OBJECT")
|
|
list(APPEND ${_target}_PRIVATE_LIBRARIES $<TARGET_OBJECTS:${framework}>)
|
|
endif ()
|
|
endif ()
|
|
endforeach ()
|
|
endmacro()
|
|
|
|
macro(WEBKIT_FRAMEWORK _target)
|
|
_WEBKIT_FRAMEWORK_LINK_FRAMEWORK(${_target})
|
|
_WEBKIT_TARGET(${_target} ${_target})
|
|
_WEBKIT_TARGET_ANALYZE(${_target})
|
|
|
|
if (${_target}_OUTPUT_NAME)
|
|
set_target_properties(${_target} PROPERTIES OUTPUT_NAME ${${_target}_OUTPUT_NAME})
|
|
endif ()
|
|
|
|
if (${_target}_PRE_BUILD_COMMAND)
|
|
add_custom_target(_${_target}_PreBuild COMMAND ${${_target}_PRE_BUILD_COMMAND} VERBATIM)
|
|
add_dependencies(${_target} _${_target}_PreBuild)
|
|
endif ()
|
|
|
|
if (${_target}_POST_BUILD_COMMAND)
|
|
add_custom_command(TARGET ${_target} POST_BUILD COMMAND ${${_target}_POST_BUILD_COMMAND} VERBATIM)
|
|
endif ()
|
|
|
|
if (APPLE AND NOT PORT STREQUAL "GTK" AND NOT ${${_target}_LIBRARY_TYPE} MATCHES STATIC)
|
|
set_target_properties(${_target} PROPERTIES FRAMEWORK TRUE)
|
|
install(TARGETS ${_target} FRAMEWORK DESTINATION ${LIB_INSTALL_DIR})
|
|
endif ()
|
|
endmacro()
|
|
|
|
# FIXME Move into WEBKIT_FRAMEWORK after all libraries are using this macro
|
|
macro(WEBKIT_FRAMEWORK_TARGET _target)
|
|
add_library(${_target}_PostBuild INTERFACE)
|
|
target_link_libraries(${_target}_PostBuild INTERFACE ${${_target}_INTERFACE_LIBRARIES})
|
|
target_include_directories(${_target}_PostBuild INTERFACE ${${_target}_INTERFACE_INCLUDE_DIRECTORIES})
|
|
add_dependencies(${_target}_PostBuild ${${_target}_INTERFACE_DEPENDENCIES})
|
|
if (NOT ${_target}_LIBRARY_TYPE STREQUAL "SHARED")
|
|
target_compile_definitions(${_target}_PostBuild INTERFACE "STATICALLY_LINKED_WITH_${_target}")
|
|
endif ()
|
|
add_library(WebKit::${_target} ALIAS ${_target}_PostBuild)
|
|
endmacro()
|
|
|
|
macro(WEBKIT_EXECUTABLE _target)
|
|
_WEBKIT_EXECUTABLE_LINK_FRAMEWORK(${_target})
|
|
_WEBKIT_TARGET(${_target} ${_target})
|
|
_WEBKIT_TARGET_ANALYZE(${_target})
|
|
|
|
if (${_target}_OUTPUT_NAME)
|
|
set_target_properties(${_target} PROPERTIES OUTPUT_NAME ${${_target}_OUTPUT_NAME})
|
|
endif ()
|
|
if (WIN32)
|
|
if (WTF_CPU_X86)
|
|
set(_processor_architecture "x86")
|
|
elseif (WTF_CPU_X86_64)
|
|
set(_processor_architecture "amd64")
|
|
else ()
|
|
set(_processor_architecture "*")
|
|
endif ()
|
|
target_link_options(${_target} PRIVATE "/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='${_processor_architecture}' publicKeyToken='6595b64144ccf1df' language='*'")
|
|
endif ()
|
|
endmacro()
|
|
|
|
macro(WEBKIT_WRAP_EXECUTABLE _target)
|
|
set(oneValueArgs TARGET_NAME)
|
|
set(multiValueArgs SOURCES LIBRARIES)
|
|
cmake_parse_arguments(opt "" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
|
|
|
|
if (opt_TARGET_NAME)
|
|
set(_wrapped_target_name ${opt_TARGET_NAME})
|
|
else ()
|
|
set(_wrapped_target_name ${_target}Lib)
|
|
endif ()
|
|
|
|
add_library(${_wrapped_target_name} SHARED "${CMAKE_BINARY_DIR}/cmakeconfig.h")
|
|
|
|
_WEBKIT_EXECUTABLE_LINK_FRAMEWORK(${_target})
|
|
_WEBKIT_TARGET(${_target} ${_wrapped_target_name})
|
|
_WEBKIT_TARGET_ANALYZE(${_wrapped_target_name})
|
|
|
|
# Unset values
|
|
unset(${_target}_HEADERS)
|
|
unset(${_target}_DEFINITIONS)
|
|
unset(${_target}_PRIVATE_DEFINITIONS)
|
|
unset(${_target}_INCLUDE_DIRECTORIES)
|
|
unset(${_target}_SYSTEM_INCLUDE_DIRECTORIES)
|
|
unset(${_target}_PRIVATE_INCLUDE_DIRECTORIES)
|
|
unset(${_target}_PRIVATE_LIBRARIES)
|
|
unset(${_target}_FRAMEWORKS)
|
|
|
|
# Reset the sources
|
|
set(${_target}_SOURCES ${opt_SOURCES})
|
|
set(${_target}_LIBRARIES ${opt_LIBRARIES})
|
|
set(${_target}_DEPENDENCIES ${_wrapped_target_name})
|
|
endmacro()
|
|
|
|
macro(WEBKIT_CREATE_FORWARDING_HEADER _target_directory _file)
|
|
get_filename_component(_source_path "${CMAKE_SOURCE_DIR}/Source/" ABSOLUTE)
|
|
get_filename_component(_absolute "${_file}" ABSOLUTE)
|
|
get_filename_component(_name "${_file}" NAME)
|
|
set(_target_filename "${_target_directory}/${_name}")
|
|
|
|
# Try to make the path in the forwarding header relative to the Source directory
|
|
# so that these forwarding headers are compatible with the ones created by the
|
|
# WebKit2 generate-forwarding-headers script.
|
|
string(REGEX REPLACE "${_source_path}/" "" _relative ${_absolute})
|
|
|
|
set(_content "#include \"${_relative}\"\n")
|
|
|
|
if (EXISTS "${_target_filename}")
|
|
file(READ "${_target_filename}" _old_content)
|
|
endif ()
|
|
|
|
if (NOT _old_content STREQUAL _content)
|
|
file(WRITE "${_target_filename}" "${_content}")
|
|
endif ()
|
|
endmacro()
|
|
|
|
function(WEBKIT_MAKE_FORWARDING_HEADERS framework)
|
|
set(options FLATTENED)
|
|
set(oneValueArgs DESTINATION TARGET_NAME)
|
|
set(multiValueArgs DIRECTORIES FILES)
|
|
cmake_parse_arguments(opt "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
|
|
set(headers ${opt_FILES})
|
|
file(MAKE_DIRECTORY ${opt_DESTINATION})
|
|
foreach (dir IN LISTS opt_DIRECTORIES)
|
|
file(GLOB files RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${dir}/*.h)
|
|
list(APPEND headers ${files})
|
|
endforeach ()
|
|
set(fwd_headers)
|
|
foreach (header IN LISTS headers)
|
|
if (IS_ABSOLUTE ${header})
|
|
set(src_header ${header})
|
|
else ()
|
|
set(src_header ${CMAKE_CURRENT_SOURCE_DIR}/${header})
|
|
endif ()
|
|
if (opt_FLATTENED)
|
|
get_filename_component(header_filename ${header} NAME)
|
|
set(fwd_header ${opt_DESTINATION}/${header_filename})
|
|
else ()
|
|
get_filename_component(header_dir ${header} DIRECTORY)
|
|
file(MAKE_DIRECTORY ${opt_DESTINATION}/${header_dir})
|
|
set(fwd_header ${opt_DESTINATION}/${header})
|
|
endif ()
|
|
add_custom_command(OUTPUT ${fwd_header}
|
|
COMMAND ${CMAKE_COMMAND} -E copy ${src_header} ${fwd_header}
|
|
MAIN_DEPENDENCY ${header}
|
|
VERBATIM
|
|
)
|
|
list(APPEND fwd_headers ${fwd_header})
|
|
endforeach ()
|
|
if (opt_TARGET_NAME)
|
|
set(target_name ${opt_TARGET_NAME})
|
|
else ()
|
|
set(target_name ${framework}ForwardingHeaders)
|
|
endif ()
|
|
add_custom_target(${target_name} DEPENDS ${fwd_headers})
|
|
add_dependencies(${framework} ${target_name})
|
|
endfunction()
|
|
|
|
function(WEBKIT_COPY_FILES target_name)
|
|
set(options FLATTENED)
|
|
set(oneValueArgs DESTINATION)
|
|
set(multiValueArgs FILES)
|
|
cmake_parse_arguments(opt "${options}" "${oneValueArgs}" "${multiValueArgs}" ${ARGN})
|
|
set(files ${opt_FILES})
|
|
set(dst_files)
|
|
foreach (file IN LISTS files)
|
|
if (IS_ABSOLUTE ${file})
|
|
set(src_file ${file})
|
|
else ()
|
|
set(src_file ${CMAKE_CURRENT_SOURCE_DIR}/${file})
|
|
endif ()
|
|
if (opt_FLATTENED)
|
|
get_filename_component(filename ${file} NAME)
|
|
set(dst_file ${opt_DESTINATION}/${filename})
|
|
else ()
|
|
get_filename_component(file_dir ${file} DIRECTORY)
|
|
file(MAKE_DIRECTORY ${opt_DESTINATION}/${file_dir})
|
|
set(dst_file ${opt_DESTINATION}/${file})
|
|
endif ()
|
|
add_custom_command(OUTPUT ${dst_file}
|
|
COMMAND ${CMAKE_COMMAND} -E copy ${src_file} ${dst_file}
|
|
MAIN_DEPENDENCY ${file}
|
|
VERBATIM
|
|
)
|
|
list(APPEND dst_files ${dst_file})
|
|
endforeach ()
|
|
add_custom_target(${target_name} ALL DEPENDS ${dst_files})
|
|
endfunction()
|
|
|
|
# Helper macros for debugging CMake problems.
|
|
macro(WEBKIT_DEBUG_DUMP_COMMANDS)
|
|
set(CMAKE_VERBOSE_MAKEFILE ON)
|
|
endmacro()
|
|
|
|
macro(WEBKIT_DEBUG_DUMP_VARIABLES)
|
|
set_cmake_property(_variableNames VARIABLES)
|
|
foreach (_variableName ${_variableNames})
|
|
message(STATUS "${_variableName}=${${_variableName}}")
|
|
endforeach ()
|
|
endmacro()
|
|
|
|
# Append the given flag to the target property.
|
|
# Builds on top of get_target_property() and set_target_properties()
|
|
macro(WEBKIT_ADD_TARGET_PROPERTIES _target _property _flags)
|
|
get_target_property(_tmp ${_target} ${_property})
|
|
if (NOT _tmp)
|
|
set(_tmp "")
|
|
endif (NOT _tmp)
|
|
|
|
foreach (f ${_flags})
|
|
set(_tmp "${_tmp} ${f}")
|
|
endforeach (f ${_flags})
|
|
|
|
set_target_properties(${_target} PROPERTIES ${_property} ${_tmp})
|
|
unset(_tmp)
|
|
endmacro()
|
|
|
|
macro(WEBKIT_POPULATE_LIBRARY_VERSION library_name)
|
|
if (NOT DEFINED ${library_name}_VERSION_MAJOR)
|
|
set(${library_name}_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
|
|
endif ()
|
|
if (NOT DEFINED ${library_name}_VERSION_MINOR)
|
|
set(${library_name}_VERSION_MINOR ${PROJECT_VERSION_MINOR})
|
|
endif ()
|
|
if (NOT DEFINED ${library_name}_VERSION_MICRO)
|
|
set(${library_name}_VERSION_MICRO ${PROJECT_VERSION_MICRO})
|
|
endif ()
|
|
if (NOT DEFINED ${library_name}_VERSION)
|
|
set(${library_name}_VERSION ${PROJECT_VERSION})
|
|
endif ()
|
|
endmacro()
|
|
|
|
macro(WEBKIT_CREATE_SYMLINK target src dest)
|
|
add_custom_command(TARGET ${target} POST_BUILD
|
|
COMMAND ln -sf ${src} ${dest}
|
|
DEPENDS ${dest}
|
|
COMMENT "Create symlink from ${src} to ${dest}")
|
|
endmacro()
|