Skip to content

Instantly share code, notes, and snippets.

@xueliu
Created August 30, 2020 20:19
Show Gist options
  • Save xueliu/f17514ff4ac52712f7fd15888275481c to your computer and use it in GitHub Desktop.
Save xueliu/f17514ff4ac52712f7fd15888275481c to your computer and use it in GitHub Desktop.
cmake_minimum_required(VERSION 3.1)
include(CMakeParseArguments)
macro(open_eebus_project)
#message(DEBUG "---- processing open_eebus_project")
set(options DEBUG)
set(oneValueArgs
PROJECT_NAME
VERSION_MAJOR
VERSION_MINOR
BUILD_VERSION
PACKAGE_NAME
)
set(multiValueArgs "")
CMAKE_PARSE_ARGUMENTS(
OPEN_EEBUS_PROJECT
"${options}"
"${oneValueArgs}"
"${multiValueArgs}"
${ARGN}
)
if(OPEN_EEBUS_PROJECT_DEBUG)
message(DEBUG " oneValueArgs ${oneValueArgs}")
message(DEBUG " OPEN_EEBUS_PROJECT_PROJECT_NAME ${OPEN_EEBUS_PROJECT_PROJECT_NAME}")
message(DEBUG " OPEN_EEBUS_PROJECT_VERSION_MAJOR ${OPEN_EEBUS_PROJECT_VERSION_MAJOR}")
message(DEBUG " OPEN_EEBUS_PROJECT_VERSION_MINOR ${OPEN_EEBUS_PROJECT_VERSION_MINOR}")
message(DEBUG " OPEN_EEBUS_PROJECT_BUILD_VERSION ${OPEN_EEBUS_PROJECT_BUILD_VERSION}")
message(DEBUG " OPEN_EEBUS_PROJECT_PACKAGE_NAME ${OPEN_EEBUS_PROJECT_PACKAGE_NAME}")
endif()
# now we have:
#
# OPEN_EEBUS_PROJECT_PROJECT_NAME
# OPEN_EEBUS_PROJECT_VERSION_MAJOR
# OPEN_EEBUS_PROJECT_VERSION_MINOR
# OPEN_EEBUS_PROJECT_BUILD_VERSION
# OPEN_EEBUS_PROJECT_PACKAGE_NAME
# ============================================================
#
# project settings
#
# ============================================================
project(${OPEN_EEBUS_PROJECT_PROJECT_NAME})
# build type
if(UNIX)
if (NOT CMAKE_BUILD_TYPE)
message(STATUS "No build target set! Assume release with debug information.")
set(CMAKE_BUILD_TYPE RELWITHDEBINFO)
elseif (CMAKE_BUILD_TYPE STREQUAL MINSIZEREL)
message(STATUS "Build type MINSIZEREL not supported. Assume release with debug information.")
set(CMAKE_BUILD_TYPE RELWITHDEBINFO)
endif()
endif(UNIX)
# version information
set(${PROJECT_NAME}_VERSION_MAJOR ${OPEN_EEBUS_PROJECT_VERSION_MAJOR} )
set(${PROJECT_NAME}_VERSION_MINOR ${OPEN_EEBUS_PROJECT_VERSION_MINOR} )
set(${PROJECT_NAME}_VERSION_REVISION ${OPEN_EEBUS_PROJECT_BUILD_VERSION} )
set(${PROJECT_NAME}_RELEASE_POSTFIX ${${PROJECT_NAME}_VERSION_MAJOR}.${${PROJECT_NAME}_VERSION_MINOR}.${${PROJECT_NAME}_VERSION_REVISION})
# ---------- Setup output Directories -------------------------
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY
${PROJECT_BINARY_DIR}/bin
CACHE PATH
"Single Directory for all dynamic Libraries"
)
# --------- Setup the Executable output Directory -------------
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY
${PROJECT_BINARY_DIR}/bin
CACHE PATH
"Single Directory for all Executables."
)
# --------- Setup the Executable output Directory -------------
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY
${PROJECT_BINARY_DIR}/lib
CACHE PATH
"Single Directory for all static libraries."
)
set(OPEN_EEBUS_VERSION_HEADER_PROJECT_NAME ${OPEN_EEBUS_PROJECT_PROJECT_NAME})
if (NOT OPEN_EEBUS_SRC)
include(OPEN_EEBUSVersionInformation)
# keep backwards compatibility
if (OPEN_EEBUS_PROJECT_PACKAGE_NAME)
set(package_name ${OPEN_EEBUS_PROJECT_PACKAGE_NAME})
else()
set(package_name ${OPEN_EEBUS_PROJECT_PROJECT_NAME})
endif()
create_open_eebus_version_header(
TARGET ${OPEN_EEBUS_PROJECT_PROJECT_NAME}versionfile
VERSION_MAJOR ${OPEN_EEBUS_PROJECT_VERSION_MAJOR}
VERSION_MINOR ${OPEN_EEBUS_PROJECT_VERSION_MINOR}
VERSION_REVISION ${OPEN_EEBUS_PROJECT_BUILD_VERSION}
PROJECT_DIR ${CMAKE_CURRENT_SOURCE_DIR}
PROJECT_NAME ${OPEN_EEBUS_VERSION_HEADER_PROJECT_NAME}
HEADER_DIR ${CMAKE_BINARY_DIR}/include
HEADER_NAME "${OPEN_EEBUS_PROJECT_PROJECT_NAME}Version.h"
PACKAGE_NAME ${package_name}
VERSION_STRING "${OPEN_EEBUS_PROJECT_PROJECT_NAME}_VERSION"
VERSION_HEADER "${OPEN_EEBUS_PROJECT_PROJECT_NAME}VERSION"
COMMENT "Create version information for ${CMAKE_CURRENT_SOURCE_DIR}"
)
endif()
include_directories(
${PROJECT_BINARY_DIR}/include/
)
# ============================================================
#
# configuration and compile settings
#
# ============================================================
if(EXISTS "${PROJECT_SOURCE_DIR}/cmake/Config.cmake.in")
include(GenerateExportHeader)
include(CMakePackageConfigHelpers)
# Configuration
set(config_install_dir "lib/cmake/${OPEN_EEBUS_PROJECT_PROJECT_NAME}")
set(generated_dir "${CMAKE_CURRENT_BINARY_DIR}/generated")
set(version_config "${generated_dir}/${OPEN_EEBUS_PROJECT_PROJECT_NAME}ConfigVersion.cmake")
set(project_config "${generated_dir}/${OPEN_EEBUS_PROJECT_PROJECT_NAME}Config.cmake")
set(targets_export_name "${OPEN_EEBUS_PROJECT_PROJECT_NAME}Targets")
set(namespace "${OPEN_EEBUS_PROJECT_PROJECT_NAME}::")
write_basic_package_version_file(
"${version_config}"
VERSION ${BS_VERSION_MAJOR}.${BS_VERSION_MINOR}.${BS_VERSION_REVISION}
COMPATIBILITY SameMajorVersion
)
# Configure '<PROJECT-NAME>Config.cmake'
# Use variables:
# * targets_export_name
# * PROJECT_NAME
configure_package_config_file(
"${PROJECT_SOURCE_DIR}/cmake/Config.cmake.in"
"${project_config}"
INSTALL_DESTINATION "${config_install_dir}"
)
# Config
# * <prefix>/lib/cmake/Foo/FooConfig.cmake
# * <prefix>/lib/cmake/Foo/FooConfigVersion.cmake
install(
FILES "${project_config}" "${version_config}"
DESTINATION "${config_install_dir}"
COMPONENT ${CPACK_COMPONENT_DEV_GROUP}
)
# Config
install(
EXPORT "${targets_export_name}"
NAMESPACE "${namespace}"
DESTINATION "${config_install_dir}"
COMPONENT ${CPACK_COMPONENT_DEV_GROUP}
)
endif()
endmacro(open_eebus_project)
macro(open_eebus_install_release_notes)
install(FILES
${PROJECT_SOURCE_DIR}/ReleaseNotes.txt
PERMISSIONS OWNER_WRITE OWNER_READ GROUP_READ WORLD_READ
DESTINATION .
COMPONENT dev
)
install(FILES
${PROJECT_SOURCE_DIR}/ReleaseNotes.txt
PERMISSIONS OWNER_WRITE OWNER_READ GROUP_READ WORLD_READ
DESTINATION .
COMPONENT bin
)
endmacro(open_eebus_install_release_notes)
macro(open_eebus_install_readme_md)
install(FILES
${PROJECT_SOURCE_DIR}/README.md
PERMISSIONS OWNER_WRITE OWNER_READ GROUP_READ WORLD_READ
DESTINATION .
COMPONENT dev
)
install(FILES
${PROJECT_SOURCE_DIR}/README.md
PERMISSIONS OWNER_WRITE OWNER_READ GROUP_READ WORLD_READ
DESTINATION .
COMPONENT bin
)
endmacro(open_eebus_install_readme_md)
macro(open_eebus_install_package_libraries)
set(oneValueArgs DESTINATION)
set(multiValueArgs
LIBRARIES
COMPONENTS
)
set(options
NO_CMAKE_FILES
DEBUG
)
CMAKE_PARSE_ARGUMENTS(
PKG
"${options}"
"${oneValueArgs}"
"${multiValueArgs}"
${ARGN}
)
if (NOT PKG_DESTINATION)
set(PKG_DESTINATION "lib")
endif()
foreach (tmp_lib ${PKG_LIBRARIES})
get_target_property(lib_location ${tmp_lib} LOCATION)
foreach (tmp_component ${PKG_COMPONENTS})
install(FILES ${lib_location}
DESTINATION ${PKG_DESTINATION}
PERMISSIONS OWNER_READ OWNER_WRITE OWNER_EXECUTE GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
COMPONENT ${tmp_component}
)
if (NOT PKG_NO_CMAKE_FILES)
get_filename_component(inst_dir ${lib_location} DIRECTORY)
if(PKG_DEBUG)
message(DEBUG " installing ${inst_dir}/cmake")
endif()
install(DIRECTORY ${inst_dir}/cmake
DESTINATION ${PKG_DESTINATION}
USE_SOURCE_PERMISSIONS
COMPONENT ${tmp_component}
)
endif()
endforeach()
endforeach()
endmacro()
function(open_eebus_install_target_sources TARGET_)
get_target_property(
${TARGET_}_sources_to_install
${TARGET_}
SOURCES
)
foreach(src ${${TARGET_}_sources_to_install})
#message(DEBUG " ------ handling source file: ${src}")
if(NOT "${src}" MATCHES "^\\$<INSTALL_INTERFACE:.*>$")
if("${src}" MATCHES "^\\$<BUILD_INTERFACE:.*>$")
string(REPLACE "$<BUILD_INTERFACE:" "" src ${src})
string(REPLACE ">" "" src ${src})
endif()
get_source_file_property(
src_full_path
${src}
LOCATION
)
string(REPLACE "${PROJECT_SOURCE_DIR}/" "" src_relative_path ${src_full_path})
get_filename_component(rel_dir ${src_relative_path} DIRECTORY)
install(FILES
${PROJECT_SOURCE_DIR}/${src_relative_path}
DESTINATION ${SOURCE_INSTALL_PREFIX}/${rel_dir}
COMPONENT ${CPACK_COMPONENT_SRC_GROUP}
)
endif()
endforeach()
endfunction()
function(dump_target_property TARGET_ PROPERTY_)
# message(DEBUG " Target : ${TARGET_}")
# message(DEBUG " Property: ${PROPERTY_}")
get_property(
property_is_set
TARGET ${TARGET_}
PROPERTY ${PROPERTY_}
SET
)
if (property_is_set)
get_target_property(
property_value
${TARGET_}
${PROPERTY_}
)
string (REPLACE ";" "\n " property_value "${property_value}")
#message(DEBUG " Value :\n ${property_value}")
else()
#message(DEBUG " Value :\n not set")
endif()
endfunction()
function(dump_target TARGET_)
message(DEBUG " =================================================================")
message(DEBUG " Dumping target properties of target: ${TARGET_}")
dump_target_property(${TARGET_} NAME)
dump_target_property(${TARGET_} EXPORT_NAME)
dump_target_property(${TARGET_} TYPE)
dump_target_property(${TARGET_} SOURCES)
dump_target_property(${TARGET_} PRIVATE_HEADER)
dump_target_property(${TARGET_} PUBLIC_HEADER)
dump_target_property(${TARGET_} INCLUDE_DIRECTORIES)
dump_target_property(${TARGET_} INTERFACE_INCLUDE_DIRECTORIES)
dump_target_property(${TARGET_} INTERFACE_SOURCES)
dump_target_property(${TARGET_} COMPILE_DEFINITIONS)
dump_target_property(${TARGET_} COMPILE_FEATURES)
dump_target_property(${TARGET_} COMPILE_FLAGS)
dump_target_property(${TARGET_} COMPILE_OPTIONS)
dump_target_property(${TARGET_} CXX_STANDARD)
dump_target_property(${TARGET_} LINK_LIBRARIES)
dump_target_property(${TARGET_} LINK_FLAGS)
message(DEBUG " =================================================================")
endfunction()
# CMake defaults:
# debug CXX_FLAGS = -g
# relwithdebinfo CXX_FLAGS = -O2 -g -DNDEBUG
# minsizerel CXX_FLAGS = -Os -DNDEBUG
# release CXX_FLAGS = -O3 -DNDEBUG
# get rid of -O3, it does not work with all toolchains
macro(remove_cxx_flag flag)
string(REPLACE "${flag}" "" CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE}")
endmacro()
remove_cxx_flag("-O3")
SET(OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_BASE "-pipe -fdiagnostics-show-option -Wall -Wextra -Werror -Wno-psabi -Wpedantic ")
SET(OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_DEBUG ${OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_BASE} "-D_DEBUG -O0")
SET(OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_RELWITHDEBINFO ${OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_BASE} "-D_DEBUG")
SET(OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_RELEASE ${OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_BASE} "-O2")
SET(OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_MINSIZE_REL ${OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_BASE})
message(INFO " To override OPEN_EEBUS compiler options set the following variables after including OPEN_EEBUSProject.cmake:")
message(INFO "")
message(INFO " OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_DEBUG")
message(INFO " OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_RELWITHDEBINFO")
message(INFO " OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_RELEASE")
message(INFO " OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_MINSIZE_REL")
# C++11 required
include(CheckCXXCompilerFlag)
CHECK_CXX_COMPILER_FLAG("-std=c++11" COMPILER_SUPPORTS_CXX11)
CHECK_CXX_COMPILER_FLAG("-std=c++0x" COMPILER_SUPPORTS_CXX0X)
set (CMAKE_CXX_STANDARD 11)
#-fPIC
set (CMAKE_POSITION_INDEPENDENT_CODE ON)
function(open_eebus_compile_options TARGET_)
string(REPLACE " " ";" opt_tmp ${OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_DEBUG})
target_compile_options(${TARGET_} PUBLIC $<$<CONFIG:DEBUG>:${opt_tmp}>)
string(REPLACE " " ";" opt_tmp ${OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_RELWITHDEBINFO})
target_compile_options(${TARGET_} PUBLIC $<$<CONFIG:RELWITHDEBINFO>:${opt_tmp}>)
string(REPLACE " " ";" opt_tmp ${OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_RELEASE})
target_compile_options(${TARGET_} PUBLIC $<$<CONFIG:RELEASE>:${opt_tmp}>)
string(REPLACE " " ";" opt_tmp ${OPEN_EEBUS_CMAKE_COMPILE_OPTIONS_MINSIZE_REL})
target_compile_options(${TARGET_} PUBLIC $<$<CONFIG:MINSIZE_REL>:${opt_tmp}>)
endfunction()
macro(open_eebus_library)
set(oneValueArgs
LIBRARY_NAME
EXPORT_NAME
HDR_RELATIVE_INSTALL_BASE_DIR
HDR_INSTALL_DIR
)
set(multiValueArgs
LIBRARY_TYPE
LIST_SRC
LIST_HDR_PRIVATE
LIST_HDR_PUBLIC
LIST_HDR_INTERFACE
INCLUDE_DIRECTORIES_PRIVATE
INCLUDE_DIRECTORIES_PUBLIC
INCLUDE_DIRECTORIES_INTERFACE
LINK_OBJECT_LIBRARIES
LINK_LIBRARIES
LINK_LIBRARIES_PRIVATE
LINK_LIBRARIES_PUBLIC
LINK_LIBRARIES_INTERFACE
)
set(options
DEBUG
)
CMAKE_PARSE_ARGUMENTS(
OPEN_EEBUS_LIBRARY
"${options}"
"${oneValueArgs}"
"${multiValueArgs}"
${ARGN}
)
if (OPEN_EEBUS_LIBRARY_DEBUG)
message(DEBUG " cmake_current_list_dir ${CMAKE_CURRENT_LIST_DIR}")
message(DEBUG " oneValueArgs ${oneValueArgs}")
message(DEBUG " OPEN_EEBUS_LIBRARY_LIBRARY_NAME ${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}")
message(DEBUG " OPEN_EEBUS_LIBRARY_LIBRARY_TYPE ${OPEN_EEBUS_LIBRARY_LIBRARY_TYPE}")
message(DEBUG " OPEN_EEBUS_LIBRARY_EXPORT_NAME ${OPEN_EEBUS_LIBRARY_EXPORT_NAME}")
message(DEBUG " OPEN_EEBUS_LIBRARY_LIST_SRC ${OPEN_EEBUS_LIBRARY_LIST_SRC}")
message(DEBUG " OPEN_EEBUS_LIBRARY_LIST_HDR_PRIVATE ${OPEN_EEBUS_LIBRARY_LIST_HDR_PRIVATE}")
message(DEBUG " OPEN_EEBUS_LIBRARY_LIST_HDR_PUBLIC ${OPEN_EEBUS_LIBRARY_LIST_HDR_PUBLIC}")
message(DEBUG " OPEN_EEBUS_LIBRARY_LIST_HDR_INTERFACE ${OPEN_EEBUS_LIBRARY_LIST_HDR_INTERFACE}")
message(DEBUG " OPEN_EEBUS_LIBRARY_INCLUDE_DIRECTORIES_PRIVATE ${OPEN_EEBUS_LIBRARY_INCLUDE_DIRECTORIES_PRIVATE}")
message(DEBUG " OPEN_EEBUS_LIBRARY_INCLUDE_DIRECTORIES_PUBLIC ${OPEN_EEBUS_LIBRARY_INCLUDE_DIRECTORIES_PUBLIC}")
message(DEBUG " OPEN_EEBUS_LIBRARY_INCLUDE_DIRECTORIES_INTERFACE ${OPEN_EEBUS_LIBRARY_INCLUDE_DIRECTORIES_INTERFACE}")
message(DEBUG " OPEN_EEBUS_LIBRARY_HDR_INSTALL_DIR ${OPEN_EEBUS_LIBRARY_HDR_INSTALL_DIR}")
message(DEBUG " OPEN_EEBUS_LIBRARY_HDR_RELATIVE_INSTALL_BASE_DIR ${OPEN_EEBUS_LIBRARY_HDR_RELATIVE_INSTALL_BASE_DIR}")
message(DEBUG " OPEN_EEBUS_LIBRARY_LINK_OBJECT_LIBRARIES ${OPEN_EEBUS_LIBRARY_LINK_OBJECT_LIBRARIES}")
message(DEBUG " OPEN_EEBUS_LIBRARY_LINK_LIBRARIES ${OPEN_EEBUS_LIBRARY_LINK_LIBRARIES}")
endif()
# now we have:
#
# OPEN_EEBUS_LIBRARY_LIBRARY_NAME
# OPEN_EEBUS_LIBRARY_LIBRARY_TYPE
# OPEN_EEBUS_LIBRARY_EXPORT_NAME
# OPEN_EEBUS_LIBRARY_LIST_SRC
# OPEN_EEBUS_LIBRARY_LIST_HDR_PRIVATE
# OPEN_EEBUS_LIBRARY_LIST_HDR_PUBLIC
# OPEN_EEBUS_LIBRARY_LIST_HDR_INTERFACE
# OPEN_EEBUS_LIBRARY_INCLUDE_DIRECTORIES_PRIVATE
# OPEN_EEBUS_LIBRARY_INCLUDE_DIRECTORIES_PUBLIC
# OPEN_EEBUS_LIBRARY_INCLUDE_DIRECTORIES_INTERFACE
# OPEN_EEBUS_LIBRARY_HDR_INSTALL_DIR
# OPEN_EEBUS_LIBRARY_HDR_RELATIVE_INSTALL_BASE_DIR
# OPEN_EEBUS_LIBRARY_LINK_OBJECT_LIBRARIES
# OPEN_EEBUS_LIBRARY_LINK_LIBRARIES
if (OPEN_EEBUS_LIBRARY_LINK_OBJECT_LIBRARIES)
set(OBJECTS_TMP $<TARGET_OBJECTS:${OPEN_EEBUS_LIBRARY_LINK_OBJECT_LIBRARIES}>)
else()
set(OBJECTS_TMP "")
endif()
# declare the target
add_library(${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}
${OPEN_EEBUS_LIBRARY_LIBRARY_TYPE}
${OBJECTS_TMP} ""
)
# set our compiler options
open_eebus_compile_options(${OPEN_EEBUS_LIBRARY_LIBRARY_NAME})
# set private source files
target_sources(${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}
PRIVATE ${OPEN_EEBUS_LIBRARY_LIST_SRC} ${OPEN_EEBUS_LIBRARY_LIST_HDR_PRIVATE}
)
############################################################
#
# target headers
#
############################################################
unset(headers_to_install)
###############################
# public headers
###############################
foreach(hdr_tmp ${OPEN_EEBUS_LIBRARY_LIST_HDR_PUBLIC})
# if we want to keep the directory structure form the source tree
# it gets tricky ...
if (OPEN_EEBUS_LIBRARY_HDR_RELATIVE_INSTALL_BASE_DIR)
# save full filename in a list
list(APPEND headers_to_install ${hdr_tmp})
# strip the base directory
string(REPLACE "${OPEN_EEBUS_LIBRARY_HDR_RELATIVE_INSTALL_BASE_DIR}/" "" hdr_tmp_file_name ${hdr_tmp})
else()
# flat installation
# strip everything, keep only the filename
get_filename_component(hdr_tmp_file_name ${hdr_tmp} NAME)
endif()
# populate the target sources property with the interface headers
# the headers are used in two ways:
# 1) library build time
# 2) build of the application the uses the library later
# the generator expression is used to distinguish between library build time
# and installation time
target_sources(${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}
PUBLIC
$<BUILD_INTERFACE:${hdr_tmp}>
$<INSTALL_INTERFACE:${OPEN_EEBUS_LIBRARY_HDR_INSTALL_DIR}/${hdr_tmp_file_name}>
)
# populate doxygen input
set(DOXYGEN_INPUT ${DOXYGEN_INPUT} ${hdr_tmp})
endforeach()
###############################
# interface headers
###############################
foreach(hdr_tmp ${OPEN_EEBUS_LIBRARY_LIST_HDR_INTERFACE})
# if we want to keep the directory structure form the source tree
# it gets tricky ...
if (OPEN_EEBUS_LIBRARY_HDR_RELATIVE_INSTALL_BASE_DIR)
# save full filename in a list
list(APPEND headers_to_install ${hdr_tmp})
# strip the base directory
string(REPLACE "${OPEN_EEBUS_LIBRARY_HDR_RELATIVE_INSTALL_BASE_DIR}/" "" hdr_tmp_file_name ${hdr_tmp})
else()
# flat installation
# strip everything, keep only the filename
get_filename_component(hdr_tmp_file_name ${hdr_tmp} NAME)
endif()
# populate the target sources property with the interface headers
# the headers are used in two ways:
# 1) library build time
# 2) build of the application the uses the library later
# the generator expression is used to distinguish between library build time
# and installation time
target_sources(${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}
INTERFACE
$<BUILD_INTERFACE:${hdr_tmp}>
$<INSTALL_INTERFACE:${OPEN_EEBUS_LIBRARY_HDR_INSTALL_DIR}/${hdr_tmp_file_name}>
)
# populate doxygen input
set(DOXYGEN_INPUT ${DOXYGEN_INPUT} ${hdr_tmp})
endforeach()
############################################################
#
# handle include directories
#
############################################################
###############################
# private
###############################
target_include_directories(${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}
PRIVATE ${OPEN_EEBUS_LIBRARY_INCLUDE_DIRECTORIES_PRIVATE}
)
###############################
# public
###############################
foreach(dir_tmp ${OPEN_EEBUS_LIBRARY_INCLUDE_DIRECTORIES_PUBLIC})
target_include_directories(${OPEN_EEBUS_LIBRARY_LIBRARY_NAME} PUBLIC
$<BUILD_INTERFACE:${dir_tmp}>
$<INSTALL_INTERFACE:${OPEN_EEBUS_LIBRARY_HDR_INSTALL_DIR}>
)
endforeach()
###############################
# interface
###############################
foreach(dir_tmp ${OPEN_EEBUS_LIBRARY_INCLUDE_DIRECTORIES_INTERFACE})
target_include_directories(${OPEN_EEBUS_LIBRARY_LIBRARY_NAME} INTERFACE
$<BUILD_INTERFACE:${dir_tmp}>
$<INSTALL_INTERFACE:${OPEN_EEBUS_LIBRARY_HDR_INSTALL_DIR}>
)
endforeach()
###############################
# object libraries
###############################
if (OPEN_EEBUS_LIBRARY_LINK_OBJECT_LIBRARIES)
foreach(objlib_tmp ${OPEN_EEBUS_LIBRARY_LINK_OBJECT_LIBRARIES})
get_target_property(
objlib_incdirs
${objlib_tmp}
INCLUDE_DIRECTORIES
)
foreach(dir_tmp ${objlib_incdirs})
get_filename_component(dir_tmp_file_name ${dir_tmp} NAME)
target_include_directories(${OPEN_EEBUS_LIBRARY_LIBRARY_NAME} PUBLIC
$<BUILD_INTERFACE:${dir_tmp}>
$<INSTALL_INTERFACE:${OPEN_EEBUS_LIBRARY_HDR_INSTALL_DIR}>
)
endforeach()
endforeach()
endif()
############################################################
#
# handle link libraries and installation
#
############################################################
# not for object libraries
if (NOT ${OPEN_EEBUS_LIBRARY_LIBRARY_TYPE} STREQUAL "OBJECT")
if (OPEN_EEBUS_LIBRARY_LINK_LIBRARIES)
# all in one argument
target_link_libraries(${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}
${OPEN_EEBUS_LIBRARY_LINK_LIBRARIES}
)
else()
# distinguish private, public, interface
target_link_libraries(${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}
PRIVATE ${OPEN_EEBUS_LIBRARY_LINK_LIBRARIES_PRIVATE}
PUBLIC ${OPEN_EEBUS_LIBRARY_LINK_LIBRARIES_PUBLIC}
INTERFACE ${OPEN_EEBUS_LIBRARY_LINK_LIBRARIES_INTERFACE}
)
endif()
set_target_properties(${OPEN_EEBUS_LIBRARY_LIBRARY_NAME} PROPERTIES VERSION "${OPEN_EEBUS_SPINE_DATAGRAM_VERSION_SHORT}" )
set_target_properties(${OPEN_EEBUS_LIBRARY_LIBRARY_NAME} PROPERTIES SOVERSION "${OPEN_EEBUS_SPINE_DATAGRAM_VERSION_SHORT}" )
# install target
install(TARGETS ${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}
EXPORT ${OPEN_EEBUS_LIBRARY_EXPORT_NAME}
PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ
LIBRARY DESTINATION lib COMPONENT ${CPACK_COMPONENT_DEV_GROUP}
ARCHIVE DESTINATION lib COMPONENT ${CPACK_COMPONENT_DEV_GROUP}
RUNTIME DESTINATION bin COMPONENT ${CPACK_COMPONENT_DEV_GROUP}
PUBLIC_HEADER DESTINATION include
INCLUDES DESTINATION include
)
# install dynamic libraries additionally in bin group
install(TARGETS ${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}
PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ
ARCHIVE DESTINATION lib COMPONENT ${CPACK_COMPONENT_BIN_GROUP}
LIBRARY DESTINATION lib COMPONENT ${CPACK_COMPONENT_BIN_GROUP}
)
endif()
############################################################
#
# install headers
#
############################################################
if (NOT OPEN_EEBUS_LIBRARY_HDR_RELATIVE_INSTALL_BASE_DIR)
# first, check if out property is set
get_property(
${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}_files_to_install_is_set
TARGET ${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}
PROPERTY INTERFACE_SOURCES
SET
)
# check for interface headers
if (${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}_files_to_install_is_set)
# get header files to install from target
get_target_property(
${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}_files_to_install
${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}
INTERFACE_SOURCES
)
# and intall them flat
install(FILES
${${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}_files_to_install}
PERMISSIONS OWNER_WRITE OWNER_READ GROUP_READ WORLD_READ
DESTINATION ${OPEN_EEBUS_LIBRARY_HDR_INSTALL_DIR}
COMPONENT ${CPACK_COMPONENT_DEV_GROUP}
)
endif()
else()
# tricky part: we want to maintain the directory structure from the source tree
# iterate over our list with complete filenames of headers to install
foreach(hdr ${headers_to_install})
# strip the base directory at front
string(REPLACE "${OPEN_EEBUS_LIBRARY_HDR_RELATIVE_INSTALL_BASE_DIR}/" "" hdr_relative ${hdr})
# strip the filename at the end to get the subdirectory
get_filename_component(subdir ${hdr_relative} DIRECTORY)
# install into the subdirectory
install(FILES
${hdr}
PERMISSIONS OWNER_WRITE OWNER_READ GROUP_READ WORLD_READ
DESTINATION "${OPEN_EEBUS_LIBRARY_HDR_INSTALL_DIR}/${subdir}"
COMPONENT ${CPACK_COMPONENT_DEV_GROUP}
)
endforeach()
endif()
# set convenience variable for dependent open_eebus modules
get_property(
${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}_interface_include_directories_is_set
TARGET ${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}
PROPERTY INTERFACE_INCLUDE_DIRECTORIES
SET
)
if (${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}_interface_include_directories_is_set)
get_target_property(
${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}_interface_include_directories
${OPEN_EEBUS_LIBRARY_LIBRARY_NAME}
INTERFACE_INCLUDE_DIRECTORIES
)
endif()
# debug output
if (OPEN_EEBUS_LIBRARY_DEBUG)
dump_target(${OPEN_EEBUS_LIBRARY_LIBRARY_NAME})
endif()
endmacro(open_eebus_library)
macro(open_eebus_executable)
set(oneValueArgs
EXECUTABLE_NAME
)
set(multiValueArgs
LIST_SRC
LIST_HDR
INCLUDE_DIRECTORIES
LINK_LIBRARIES
)
set(options
NO_DOC
NO_INSTALL
DEBUG
)
CMAKE_PARSE_ARGUMENTS(
OPEN_EEBUS_EXECUTABLE
"${options}"
"${oneValueArgs}"
"${multiValueArgs}"
${ARGN}
)
if (OPEN_EEBUS_EXECUTABLE_DEBUG)
message(DEBUG " oneValueArgs ${oneValueArgs}")
message(DEBUG " OPEN_EEBUS_EXECUTABLE_EXECUTABLE_NAME ${OPEN_EEBUS_EXECUTABLE_EXECUTABLE_NAME}")
message(DEBUG " OPEN_EEBUS_EXECUTABLE_LIST_SRC ${OPEN_EEBUS_EXECUTABLE_LIST_SRC}")
message(DEBUG " OPEN_EEBUS_EXECUTABLE_LIST_HDR ${OPEN_EEBUS_EXECUTABLE_LIST_HDR}")
message(DEBUG " OPEN_EEBUS_EXECUTABLE_INCLUDE_DIRECTORIES ${OPEN_EEBUS_EXECUTABLE_INCLUDE_DIRECTORIES}")
message(DEBUG " OPEN_EEBUS_EXECUTABLE_LINK_LIBRARIES ${OPEN_EEBUS_EXECUTABLE_LINK_LIBRARIES}")
endif()
# now we have:
#
# OPEN_EEBUS_EXECUTABLE_EXECUTABLE_NAME
# OPEN_EEBUS_EXECUTABLE_LIST_SRC
# OPEN_EEBUS_EXECUTABLE_LIST_HDR
# OPEN_EEBUS_EXECUTABLE_INCLUDE_DIRECTORIES
# OPEN_EEBUS_EXECUTABLE_LINK_LIBRARIES
add_executable(${OPEN_EEBUS_EXECUTABLE_EXECUTABLE_NAME}
${OPEN_EEBUS_EXECUTABLE_LIST_SRC}
${OPEN_EEBUS_EXECUTABLE_LIST_HDR}
)
open_eebus_compile_options(${OPEN_EEBUS_EXECUTABLE_EXECUTABLE_NAME})
if (OPEN_EEBUS_EXECUTABLE_INCLUDE_DIRECTORIES)
target_include_directories(${OPEN_EEBUS_EXECUTABLE_EXECUTABLE_NAME} PRIVATE
${OPEN_EEBUS_EXECUTABLE_INCLUDE_DIRECTORIES}
)
endif()
target_link_libraries(${OPEN_EEBUS_EXECUTABLE_EXECUTABLE_NAME}
${OPEN_EEBUS_EXECUTABLE_LINK_LIBRARIES}
)
if (NOT OPEN_EEBUS_EXECUTABLE_NO_INSTALL)
install(TARGETS ${OPEN_EEBUS_EXECUTABLE_EXECUTABLE_NAME}
PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_EXECUTE GROUP_READ WORLD_EXECUTE WORLD_READ
LIBRARY DESTINATION lib COMPONENT ${CPACK_COMPONENT_BIN_GROUP}
ARCHIVE DESTINATION lib COMPONENT ${CPACK_COMPONENT_DEV_GROUP}
RUNTIME DESTINATION bin COMPONENT ${CPACK_COMPONENT_BIN_GROUP}
)
endif()
if (NOT OPEN_EEBUS_EXECUTABLE_NO_DOC)
set(DOXYGEN_INPUT ${DOXYGEN_INPUT} ${OPEN_EEBUS_EXECUTABLE_LIST_HDR})
endif()
if (OPEN_EEBUS_EXECUTABLE_DEBUG)
dump_target(${OPEN_EEBUS_EXECUTABLE_EXECUTABLE_NAME})
endif()
endmacro(open_eebus_executable)
macro(GENERATE_KEYMATERIAL)
set(oneValueArgs
TARGET
PREFIX
OUTPUT_DIR)
set(multiValueArgs)
CMAKE_PARSE_ARGUMENTS(
KEYMATERIAL
"${options}"
"${oneValueArgs}"
"${multiValueArgs}"
${ARGN})
message(DEBUG " oneValueArgs ${oneValueArgs}")
message(DEBUG " KEYMATERIAL_TARGET ${KEYMATERIAL_TARGET}")
message(DEBUG " KEYMATERIAL_PREFIX ${KEYMATERIAL_PREFIX}")
message(DEBUG " KEYMATERIAL_OUTPUT_DIR ${KEYMATERIAL_OUTPUT_DIR}")
set(SSL_PREFIX "secp256r1")
set(SSL_KEY_BIN "${KEYMATERIAL_PREFIX}.${SSL_PREFIX}KeyDER.bin")
set(SSL_CERT_BIN "${KEYMATERIAL_PREFIX}.${SSL_PREFIX}CertDER.bin")
set(SSL_OUTPUT ${KEYMATERIAL_OUTPUT_DIR}/${SSL_KEY_BIN} ${KEYMATERIAL_OUTPUT_DIR}/${SSL_CERT_BIN})
file(MAKE_DIRECTORY ${KEYMATERIAL_OUTPUT_DIR})
set (SSL_CMDLINE_1
ecparam -out ${SSL_PREFIX}params.pem -name ${SSL_PREFIX} -conv_form compressed -genkey
)
set (SSL_CMDLINE_2
req -x509 -newkey ec:${SSL_PREFIX}params.pem
-keyform PEM -keyout ${SSL_PREFIX}KeyDER.pem
-outform PEM
-out ${SSL_PREFIX}CertDER.pem
-days 3650
-set_serial 1234
-nodes
-batch
)
set (SSL_CMDLINE_3
x509 -in ${SSL_PREFIX}CertDER.pem -inform PEM -out ${SSL_CERT_BIN} -outform DER
)
set (SSL_CMDLINE_4
ec -in ${SSL_PREFIX}KeyDER.pem -out ${SSL_KEY_BIN} -outform DER
)
# generate key material
add_custom_command(
OUTPUT ${SSL_OUTPUT}
COMMAND rm -f ${SSL_PREFIX}*
COMMAND openssl ${SSL_CMDLINE_1}
COMMAND openssl ${SSL_CMDLINE_2}
COMMAND openssl ${SSL_CMDLINE_3}
COMMAND openssl ${SSL_CMDLINE_4}
COMMAND rm -f ${SSL_PREFIX}CertDER.pem ${SSL_PREFIX}KeyDER.pem ${SSL_PREFIX}params.pem
WORKING_DIRECTORY ${KEYMATERIAL_OUTPUT_DIR}
COMMENT "*******************Generate Key Material in ${KEYMATERIAL_OUTPUT_DIR}"
)
add_custom_target(
${KEYMATERIAL_TARGET}
DEPENDS ${SSL_OUTPUT}
)
endmacro(GENERATE_KEYMATERIAL)
macro(open_eebus_docker)
set(options "")
set(oneValueArgs
IMAGE_NAME
FROM
FILES_DIRECTORY
ADDITIONAL_PROVISIONING_STEPS
ADDITIONAL_PACKAGES
)
set(multiValueArgs
)
CMAKE_PARSE_ARGUMENTS(
OPEN_EEBUS_DOCKER
"${options}"
"${oneValueArgs}"
"${multiValueArgs}"
${ARGN}
)
set(${OPEN_EEBUS_DOCKER_IMAGE_NAME}_workdir ${PROJECT_BINARY_DIR}/docker-${OPEN_EEBUS_DOCKER_IMAGE_NAME})
message(DEBUG " oneValueArgs ${oneValueArgs}")
message(DEBUG " OPEN_EEBUS_DOCKER_IMAGE_NAME ${OPEN_EEBUS_DOCKER_IMAGE_NAME}")
message(DEBUG " OPEN_EEBUS_DOCKER_FROM ${OPEN_EEBUS_DOCKER_FROM}")
message(DEBUG " OPEN_EEBUS_DOCKER_FILES_DIRECTORY ${OPEN_EEBUS_DOCKER_FILES_DIRECTORY}")
message(DEBUG " OPEN_EEBUS_DOCKER_ADDITIONAL_PROVISIONING_STEPS ${OPEN_EEBUS_DOCKER_ADDITIONAL_PROVISIONING_STEPS}")
message(DEBUG " OPEN_EEBUS_DOCKER_ADDITIONAL_PACKAGES ${OPEN_EEBUS_DOCKER_ADDITIONAL_PACKAGES}")
message(DEBUG " Working directory ${${OPEN_EEBUS_DOCKER_IMAGE_NAME}_workdir}")
set(SSL_PREFIX "secp256r1")
set(SSL_KEY_BIN "${SSL_PREFIX}KeyDER.bin")
set(SSL_CERT_BIN "${SSL_PREFIX}CertDER.bin")
set(SSL_OUTPUT ${OPEN_EEBUS_DOCKER_IMAGE_NAME}_workdir/${SSL_KEY_BIN} ${OPEN_EEBUS_DOCKER_IMAGE_NAME}_workdir/${SSL_CERT_BIN})
set (SSL_CMDLINE_1
ecparam -out ${SSL_PREFIX}params.pem -name ${SSL_PREFIX} -conv_form compressed -genkey
)
set (SSL_CMDLINE_2
req -x509 -newkey ec:${SSL_PREFIX}params.pem
-keyform PEM -keyout ${SSL_PREFIX}KeyDER.pem
-outform PEM
-out ${SSL_PREFIX}CertDER.pem
-days 3650
-set_serial 1234
-nodes
-batch
)
set (SSL_CMDLINE_3
x509 -in ${SSL_PREFIX}CertDER.pem -inform PEM -out ${SSL_CERT_BIN} -outform DER
)
set (SSL_CMDLINE_4
ec -in ${SSL_PREFIX}KeyDER.pem -out ${SSL_KEY_BIN} -outform DER
)
# generate key material
add_custom_command(
OUTPUT ${SSL_OUTPUT}
COMMAND rm -f ${SSL_PREFIX}*
COMMAND openssl ${SSL_CMDLINE_1}
COMMAND openssl ${SSL_CMDLINE_2}
COMMAND openssl ${SSL_CMDLINE_3}
COMMAND openssl ${SSL_CMDLINE_4}
WORKING_DIRECTORY ${${OPEN_EEBUS_DOCKER_IMAGE_NAME}_workdir}
COMMENT "Generate Key Material"
)
add_custom_target(
GenerateKeyMaterial-${OPEN_EEBUS_DOCKER_IMAGE_NAME}
DEPENDS ${SSL_OUTPUT}
)
set(DOCKERFILE "${CMAKE_CURRENT_LIST_DIR}/Dockerfile-${OPEN_EEBUS_DOCKER_IMAGE_NAME}")
if(EXISTS ${DOCKERFILE})
file(READ ${DOCKERFILE} FILE_CONTENT)
else()
set(FILE_CONTENT
"FROM ${OPEN_EEBUS_DOCKER_FROM}\n"
"\n"
"RUN apt-get update -y\n"
"\n"
"RUN apt-get install -y libavahi-client3 avahi-utils avahi-daemon ${OPEN_EEBUS_DOCKER_ADDITIONAL_PACKAGES}\n"
"\n"
"COPY secp256r1KeyDER.bin /tmp/\n"
"COPY secp256r1CertDER.bin /tmp/\n"
"\n"
"COPY *-bin.tar.gz /tmp/package_bin.tgz\n"
"COPY *-dev.tar.gz /tmp/package_dev.tgz\n"
"RUN tar xzf /tmp/package_bin.tgz -C /usr\n"
"RUN tar xzf /tmp/package_dev.tgz -C /usr\n"
${OPEN_EEBUS_DOCKER_ADDITIONAL_PROVISIONING_STEPS}
"# workaround for broken systemv init scripts of Ubuntu 14.04\n"
"# RUN ln -sf /bin/dbus-daemon /usr/bin/dbus-daemon\n"
"RUN mkdir /var/run/dbus\n"
"\n"
"EXPOSE 16368\n"
"\n"
"CMD chmod +x /tmp/open_eebusrunscript.sh\n"
"CMD /tmp/open_eebusrunscript.sh\n"
)
endif()
file(WRITE "${${OPEN_EEBUS_DOCKER_IMAGE_NAME}_workdir}/Dockerfile" ${FILE_CONTENT})
set(DOCKER_CMD_LINE build -t ${OPEN_EEBUS_DOCKER_IMAGE_NAME} .)
set_source_files_properties(
docker_output-${OPEN_EEBUS_DOCKER_IMAGE_NAME}
PROPERTIES SYMBOLIC(True)
)
# generate docker image
add_custom_command(
OUTPUT ${${OPEN_EEBUS_DOCKER_IMAGE_NAME}_workdir}/docker_output-${OPEN_EEBUS_DOCKER_IMAGE_NAME}
COMMAND cd ${PROJECT_BINARY_DIR} && rm -f *-bin.tar.gz *-dev.tar.gz
COMMAND cd ${PROJECT_BINARY_DIR} && make package
COMMAND mkdir -p ${${OPEN_EEBUS_DOCKER_IMAGE_NAME}_workdir}/docker
COMMAND rm -f ${${OPEN_EEBUS_DOCKER_IMAGE_NAME}_workdir}/docker/*
COMMAND cp -f ${PROJECT_BINARY_DIR}/*-dev.tar.gz ${${OPEN_EEBUS_DOCKER_IMAGE_NAME}_workdir}
COMMAND cp -f ${PROJECT_BINARY_DIR}/*-bin.tar.gz ${${OPEN_EEBUS_DOCKER_IMAGE_NAME}_workdir}
COMMAND cp -rfa ${CMAKE_CURRENT_LIST_DIR}/${OPEN_EEBUS_DOCKER_FILES_DIRECTORY}/* ${${OPEN_EEBUS_DOCKER_IMAGE_NAME}_workdir}/docker/
COMMAND docker ${DOCKER_CMD_LINE}
DEPENDS GenerateKeyMaterial-${OPEN_EEBUS_DOCKER_IMAGE_NAME}
WORKING_DIRECTORY ${${OPEN_EEBUS_DOCKER_IMAGE_NAME}_workdir}
COMMENT "Generate Docker Image ${OPEN_EEBUS_DOCKER_IMAGE_NAME}"
)
add_custom_target(
DockerImage-${OPEN_EEBUS_DOCKER_IMAGE_NAME}
DEPENDS ${${OPEN_EEBUS_DOCKER_IMAGE_NAME}_workdir}/docker_output-${OPEN_EEBUS_DOCKER_IMAGE_NAME}
)
endmacro(open_eebus_docker)
macro(open_eebus_convertUmlet)
set(options "")
set(oneValueArgs
INPUT_FILES
OUT_DIR
FORMAT
)
set(multiValueArgs
)
CMAKE_PARSE_ARGUMENTS(
OPEN_EEBUS_UMLET
"${options}"
"${oneValueArgs}"
"${multiValueArgs}"
${ARGN}
)
message(DEBUG " oneValueArgs ${oneValueArgs}")
message(DEBUG " OPEN_EEBUS_UMLET_INPUT_FILES ${OPEN_EEBUS_UMLET_INPUT_FILES}")
message(DEBUG " OPEN_EEBUS_UMLET_OUT_DIR ${OPEN_EEBUS_UMLET_OUT_DIR}")
message(DEBUG " OPEN_EEBUS_UMLET_FORMAT ${OPEN_EEBUS_UMLET_FORMAT}")
set(FILE_CONTENT
"#! /usr/bin/python\n"
"\n"
"import os\n"
"import sys\n"
"import subprocess\n"
"import multiprocessing\n"
"\n"
"# globals!\n"
"uxf = ''\n"
"outdir = ''\n"
"umlet = ''\n"
"\n"
"def do_calculation(fname):\n"
"\n"
" outname = os.path.basename(fname).rstrip('.uxf')\n"
" cmd = 'java -jar ' + umlet + ' -action=convert -format=${OPEN_EEBUS_UMLET_FORMAT} -filename=' + fname + ' -output=' + os.path.join(outdir,outname) + '.${OPEN_EEBUS_UMLET_FORMAT}'\n"
" print cmd\n"
" process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)\n"
" o = process.communicate()[0]\n"
" output = str(o)\n"
" return output\n"
"\n"
"\n"
"\n"
"def start_process():\n"
" #print 'Starting', multiprocessing.current_process().name\n"
" pass\n"
"\n"
"if __name__ == '__main__':\n"
" uxf = sys.argv[1]\n"
" outdir= sys.argv[2]\n"
" umlet = sys.argv[3]\n"
"\n"
" inputs = []\n"
" with open(uxf) as f:\n"
" for line in f:\n"
" inputs.append(line.strip())\n"
"\n"
" print 'Input :', inputs\n"
"\n"
" pool_size = multiprocessing.cpu_count() * 16\n"
" pool = multiprocessing.Pool(processes=pool_size,\n"
" initializer=start_process,\n"
" )\n"
" pool_outputs = pool.map(do_calculation, inputs)\n"
" pool.close() # no more tasks\n"
" pool.join() # wrap up current tasks\n"
"\n"
" print 'Pool :', pool_outputs\n"
)
file(WRITE "${OPEN_EEBUS_UMLET_OUT_DIR}/convert.py" ${FILE_CONTENT})
set (UXFFILE "${OPEN_EEBUS_UMLET_OUT_DIR}/uxf.txt")
set(GENERATED_LIST_FILES )
file(WRITE ${UXFFILE} " ")
foreach(infileName ${OPEN_EEBUS_UMLET_INPUT_FILES})
file(APPEND ${UXFFILE} ${infileName} "\n")
# get_filename_component(<VAR> <FileName> <COMP> [CACHE])
# DIRECTORY = Directory without file name
# NAME = File name without directory
# EXT = File name longest extension (.b.c from d/a.b.c)
# NAME_WE = File name without directory or longest extension
# ABSOLUTE = Full path to file
# REALPATH = Full path to existing file with symlinks resolved
# PATH = Legacy alias for DIRECTORY (use for CMake <= 2.8.11)
get_filename_component(pdfFile ${infileName} NAME_WE)
list( APPEND GENERATED_LIST_FILES "${OPEN_EEBUS_UMLET_OUT_DIR}/${pdfFile}.svg")
endforeach()
SET_SOURCE_FILES_PROPERTIES(
${GENERATED_LIST_FILES}
PROPERTIES GENERATED TRUE
)
add_custom_command(
OUTPUT ${GENERATED_LIST_FILES}
COMMAND "python" "${OPEN_EEBUS_UMLET_OUT_DIR}/convert.py" "${UXFFILE}" "${OPEN_EEBUS_UMLET_OUT_DIR}" "${UMLET_EXECUTABLE}"
WORKING_DIRECTORY "${OPEN_EEBUS_UMLET_OUT_DIR}"
COMMENT "************************************** Converting uxf to ${OPEN_EEBUS_UMLET_FORMAT} in ${OPEN_EEBUS_UMLET_OUT_DIR} ************************************"
DEPENDS ${OPEN_EEBUS_UMLET_INPUT_FILES}
)
message(STATUS " GENERATED_LIST_FILES= ${GENERATED_LIST_FILES}")
add_custom_target(
ConvertUmlet
DEPENDS ${GENERATED_LIST_FILES}
)
endmacro(open_eebus_convertUmlet)
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment