cmake/common.cmake

   1 ###########################################################################
   2 # Copyright 2015, 2016, 2017 IoT.bzh
   3 #
   4 # author: Fulup Ar Foll <fulup@iot.bzh>
   5 # contrib: Romain Forlot <romain.forlot@iot.bzh>
   6 #
   7 # Licensed under the Apache License, Version 2.0 (the "License");
   8 # you may not use this file except in compliance with the License.
   9 # You may obtain a copy of the License at
  10 #
  11 #     http://www.apache.org/licenses/LICENSE-2.0
  12 #
  13 # Unless required by applicable law or agreed to in writing, software
  14 # distributed under the License is distributed on an "AS IS" BASIS,
  15 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 # See the License for the specific language governing permissions and
  17 # limitations under the License.
  18 ###########################################################################
  19
  20
  21 #--------------------------------------------------------------------------
  22 #  WARNING:
  23 #     Do not change this cmake template
  24 #     Customise your preferences in "./etc/config.cmake"
  25 #--------------------------------------------------------------------------
  26
  27 # Get colorized message output non Windows OS. You know bash ? :)
  28 if(NOT WIN32)
  29   string(ASCII 27 Esc)
  30   set(ColourReset "${Esc}[m")
  31   set(ColourBold  "${Esc}[1m")
  32   set(Red         "${Esc}[31m")
  33   set(Green       "${Esc}[32m")
  34   set(Yellow      "${Esc}[33m")
  35   set(Blue        "${Esc}[34m")
  36   set(Magenta     "${Esc}[35m")
  37   set(Cyan        "${Esc}[36m")
  38   set(White       "${Esc}[37m")
  39   set(BoldRed     "${Esc}[1;31m")
  40   set(BoldGreen   "${Esc}[1;32m")
  41   set(BoldYellow  "${Esc}[1;33m")
  42   set(BoldBlue    "${Esc}[1;34m")
  43   set(BoldMagenta "${Esc}[1;35m")
  44   set(BoldCyan    "${Esc}[1;36m")
  45   set(BoldWhite   "${Esc}[1;37m")
  46 endif()
  47
  48 # Generic useful macro
  49 # -----------------------
  50 macro(PROJECT_TARGET_ADD TARGET_NAME)
  51         set_property(GLOBAL APPEND PROPERTY PROJECT_TARGETS ${TARGET_NAME})
  52         set(TARGET_NAME ${TARGET_NAME})
  53 endmacro(PROJECT_TARGET_ADD)
  54
  55 macro(PROJECT_PKGDEP_ADD PKG_NAME)
  56         set_property(GLOBAL APPEND PROPERTY PROJECT_PKG_DEPS ${PKG_NAME})
  57 endmacro(PROJECT_PKGDEP_ADD)
  58
  59 # Check GCC minimal version
  60 if (gcc_minimal_version)
  61         message (STATUS "${Blue}-- Check gcc_minimal_version (found gcc version ${CMAKE_C_COMPILER_VERSION})  (found g++ version ${CMAKE_CXX_COMPILER_VERSION})${ColourReset}")
  62 if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS ${gcc_minimal_version} OR CMAKE_C_COMPILER_VERSION VERSION_LESS ${gcc_minimal_version})
  63         message(FATAL_ERROR "${Red}**** FATAL: Require at least gcc-${gcc_minimal_version} please set CMAKE_C[XX]_COMPILER")
  64 endif()
  65 endif(gcc_minimal_version)
  66
  67 # Check Kernel minimal version
  68 if (kernel_minimal_version)
  69         message (STATUS "${Blue}-- Check kernel_minimal_version (found kernel version ${CMAKE_SYSTEM_VERSION})${ColourReset}")
  70         if (CMAKE_SYSTEM_VERSION VERSION_LESS ${kernel_minimal_version})
  71         message(FATAL_ERROR "${Red}**** FATAL: Require at least ${kernel_minimal_version} please use a recent kernel.")
  72 endif()
  73 endif(kernel_minimal_version)
  74
  75 macro(defstr name value)
  76         add_definitions(-D${name}=${value})
  77 endmacro(defstr)
  78
  79 # Native packaging name
  80 set(NPKG_PROJECT_NAME agl-${PROJECT_NAME})
  81
  82 # Pre-packaging
  83 macro(project_targets_populate)
  84         # Default Widget default directory
  85         set(PACKAGE_BINDIR  ${PROJECT_PKG_BUILD_DIR}/bin)
  86         set(PACKAGE_ETCDIR  ${PROJECT_PKG_BUILD_DIR}/etc)
  87         set(PACKAGE_LIBDIR  ${PROJECT_PKG_BUILD_DIR}/lib)
  88         set(PACKAGE_HTTPDIR ${PROJECT_PKG_BUILD_DIR}/htdocs)
  89         set(PACKAGE_DATADIR ${PROJECT_PKG_BUILD_DIR}/data)
  90
  91         add_custom_target(populate)
  92                 get_property(PROJECT_TARGETS GLOBAL PROPERTY PROJECT_TARGETS)
  93         foreach(TARGET ${PROJECT_TARGETS})
  94                 get_target_property(T ${TARGET} LABELS)
  95                 if(T)
  96                         # Declaration of a custom command that will populate widget tree with the target
  97                         set(POPULE_PACKAGE_TARGET "project_populate_${TARGET}")
  98
  99                         get_target_property(P ${TARGET} PREFIX)
 100                         get_target_property(BD ${TARGET} BINARY_DIR)
 101                         get_target_property(OUT ${TARGET} OUTPUT_NAME)
 102
 103                         if(P MATCHES "NOTFOUND$")
 104                                 if (${T} STREQUAL "BINDING")
 105                                         set(P "lib")
 106                                 else()
 107                                         set(P "")
 108                                 endif()
 109                         endif()
 110
 111                         if(${T} STREQUAL "BINDING")
 112                                 add_custom_command(OUTPUT ${PACKAGE_LIBDIR}/${P}${TARGET}.so
 113                                         DEPENDS ${TARGET}
 114                                         COMMAND mkdir -p ${PACKAGE_LIBDIR}
 115                                         COMMAND cp ${BD}/${P}${OUT}.so ${PACKAGE_LIBDIR}
 116                                 )
 117                                 add_custom_target(${POPULE_PACKAGE_TARGET} DEPENDS ${PACKAGE_LIBDIR}/${P}${TARGET}.so)
 118                                 add_dependencies(populate ${POPULE_PACKAGE_TARGET})
 119                         elseif(${T} STREQUAL "EXECUTABLE")
 120                                 add_custom_command(OUTPUT ${PACKAGE_BINDIR}/${P}${TARGET}
 121                                         DEPENDS ${TARGET}
 122                                         COMMAND mkdir -p ${PACKAGE_BINDIR}
 123                                         COMMAND cp ${BD}/${P}${OUT} ${PACKAGE_BINDIR}
 124                                 )
 125                                 add_custom_target(${POPULE_PACKAGE_TARGET} DEPENDS ${PACKAGE_BINDIR}/${P}${TARGET})
 126                                 add_dependencies(populate ${POPULE_PACKAGE_TARGET})
 127                         elseif(${T} STREQUAL "HTDOCS")
 128                                 add_custom_command(OUTPUT ${PACKAGE_HTTPDIR}-xx
 129                                         DEPENDS ${TARGET}
 130                                         COMMAND mkdir -p ${PACKAGE_HTTPDIR}
 131                                         COMMAND touch ${PACKAGE_HTTPDIR}
 132                                         COMMAND cp -r ${BD}/${P}${OUT}/* ${PACKAGE_HTTPDIR}
 133                                 )
 134                                         add_custom_target(${POPULE_PACKAGE_TARGET} DEPENDS ${PACKAGE_HTTPDIR}-xx)
 135                                         add_dependencies(populate ${POPULE_PACKAGE_TARGET})
 136                         elseif(${T} STREQUAL "DATA")
 137                                 add_custom_command(OUTPUT ${PACKAGE_DATADIR}-xx
 138                                         DEPENDS ${TARGET}
 139                                         COMMAND mkdir -p ${PACKAGE_DATADIR}
 140                                         COMMAND touch ${PACKAGE_DATADIR}
 141                                         COMMAND cp -r ${BD}/${P}${OUT} ${PACKAGE_DATADIR}
 142                                 )
 143                                         add_custom_target(${POPULE_PACKAGE_TARGET} DEPENDS ${PACKAGE_DATADIR}-xx)
 144                                         add_dependencies(populate ${POPULE_PACKAGE_TARGET})
 145                         endif(${T} STREQUAL "BINDING")
 146                 elseif(${CMAKE_BUILD_TYPE} MATCHES "[Dd][Ee][Bb][Uu][Gg]")
 147                         MESSAGE(".. Warning: ${TARGET} ignored when packaging.")
 148                 endif()
 149         endforeach()
 150 endmacro(project_targets_populate)
 151
 152 macro(remote_targets_populate)
 153         if (DEFINED ENV{RSYNC_TARGET})
 154         set (RSYNC_TARGET $ENV{RSYNC_TARGET})
 155         endif()
 156         if (DEFINED ENV{RSYNC_PREFIX})
 157         set (RSYNC_PREFIX $ENV{RSYNC_PREFIX})
 158         endif()
 159
 160         set(
 161                 REMOTE_LAUNCH "Test on target with: ${CMAKE_CURRENT_BINARY_DIR}/target/start-on-${RSYNC_TARGET}.sh"
 162                 CACHE STRING "Command to start ${PROJECT_NAME} on remote target ${RSYNC_TARGET}"
 163         )
 164
 165         if(NOT RSYNC_TARGET OR NOT RSYNC_PREFIX)
 166                 message ("${Yellow}.. Warning: RSYNC_TARGET RSYNC_PREFIX not defined 'make remote-target-populate' not instanciated${ColourReset}")
 167                 add_custom_target(remote-target-populate
 168                         COMMENT "${Red}*** Fatal: RSYNC_TARGET RSYNC_PREFIX environment variables required with 'make remote-target-populate'${ColourReset}"
 169                         COMMAND exit -1
 170                 )
 171         else()
 172
 173                 configure_file(${SSH_TEMPLATE_DIR}/start-on-target.in ${CMAKE_CURRENT_BINARY_DIR}/target/start-on-${RSYNC_TARGET}.sh)
 174                 configure_file(${GDB_TEMPLATE_DIR}/gdb-on-target.in ${CMAKE_CURRENT_BINARY_DIR}/target/gdb-on-${RSYNC_TARGET}.ini)
 175
 176                 add_custom_target(remote-target-populate
 177                         DEPENDS populate
 178                         COMMAND chmod +x ${CMAKE_CURRENT_BINARY_DIR}/target/*.sh
 179                         COMMAND rsync -e "ssh -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null" --archive --delete ${PROJECT_PKG_BUILD_DIR}/ ${RSYNC_TARGET}:${RSYNC_PREFIX}/${PROJECT_NAME}
 180                         COMMENT "${REMOTE_LAUNCH}"
 181                 )
 182         endif()
 183 endmacro(remote_targets_populate)
 184
 185 macro(wgt_package_build)
 186         if(NOT EXISTS ${WIDGET_CONFIG_TEMPLATE})
 187                 MESSAGE(FATAL_ERROR "${Red}WARNING ! Missing mandatory files to build widget file.\nYou need a config.xml template: please specify WIDGET_CONFIG_TEMPLATE correctly.${ColourReset}")
 188         endif()
 189         if(NOT EXISTS ${WGT_TEMPLATE_DIR}/icon-default.png)
 190                 MESSAGE(FATAL_ERROR "${Red}WARNING ! Missing mandatory files to build widget file.\nYou need ${PROJECT_ICON} file in ${WGT_TEMPLATE_DIR} folder.${ColourReset}")
 191         endif()
 192     if(NOT WIDGET_TYPE)
 193         MESSAGE(FATAL_ERROR "WIDGET_TYPE must be set in your config.cmake.\neg.: set(WIDGET_TYPE application/vnd.agl.service)")
 194     endif()
 195
 196         if(NOT WIDGET_ENTRY_POINT)
 197                 set(WIDGET_ENTRY_POINT lib)
 198         endif()
 199
 200         add_custom_command(OUTPUT ${PROJECT_PKG_BUILD_DIR}/config.xml
 201                 COMMAND ${CMAKE_COMMAND} -DINFILE=${WIDGET_CONFIG_TEMPLATE} -DOUTFILE=${PROJECT_PKG_BUILD_DIR}/config.xml -DPROJECT_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR} -P ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_APP_TEMPLATES_DIR}/cmake/configure_file.cmake
 202                 COMMAND cp ${WGT_TEMPLATE_DIR}/icon-default.png ${PROJECT_PKG_BUILD_DIR}/${PROJECT_ICON}
 203
 204         )
 205         add_custom_target(packaging_wgt DEPENDS ${PROJECT_PKG_BUILD_DIR}/config.xml)
 206
 207         # Fulup ??? copy any extra file in wgt/etc into populate package before building the widget
 208         file(GLOB PROJECT_CONF_FILES "${WGT_TEMPLATE_DIR}/etc/*")
 209         if(${PROJECT_CONF_FILES})
 210                 file(COPY "${WGT_TEMPLATE_DIR}/etc/*" DESTINATION ${PROJECT_PKG_BUILD_DIR}/etc/)
 211         endif(${PROJECT_CONF_FILES})
 212
 213         add_custom_command(OUTPUT ${PROJECT_NAME}.wgt
 214                 DEPENDS ${PROJECT_TARGETS}
 215                 COMMAND wgtpkg-pack -f -o ${PROJECT_NAME}.wgt ${PROJECT_PKG_BUILD_DIR}
 216         )
 217
 218         add_custom_target(widget DEPENDS ${PROJECT_NAME}.wgt)
 219         add_dependencies(widget populate packaging_wgt)
 220         set(ADDITIONAL_MAKE_CLEAN_FILES, "${PROJECT_NAME}.wgt")
 221
 222         if(NOT RSYNC_TARGET)
 223                 message ("${Yellow}.. Warning: RSYNC_TARGET not defined 'make widget-target-install' not instanciated${ColourReset}")
 224                 add_custom_target(widget-target-install
 225                         COMMENT "${Red}*** Fatal: RSYNC_TARGET RSYNC_PREFIX environment variables required with 'make widget-target-install'${ColourReset}"
 226                         COMMAND exit -1
 227                 )
 228         else()
 229         configure_file(${WGT_TEMPLATE_DIR}/install-wgt-on-target.in ${CMAKE_CURRENT_BINARY_DIR}/target/install-wgt-on-${RSYNC_TARGET}.sh)
 230         add_custom_target(widget-target-install
 231             DEPENDS widget
 232             COMMAND chmod +x ${CMAKE_CURRENT_BINARY_DIR}/target/install-wgt-on-${RSYNC_TARGET}.sh
 233             COMMAND ${CMAKE_CURRENT_BINARY_DIR}/target/install-wgt-on-${RSYNC_TARGET}.sh
 234         )
 235     endif()
 236
 237         if(PACKAGE_MESSAGE)
 238         add_custom_command(TARGET widget
 239                 POST_BUILD
 240                 COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --cyan "++ ${PACKAGE_MESSAGE}")
 241         endif()
 242 endmacro(wgt_package_build)
 243
 244 macro(rpm_package_build)
 245         add_custom_command(OUTPUT ${NPKG_PROJECT_NAME}.spec
 246                 DEPENDS ${PROJECT_TARGETS}
 247                                 archive
 248                                 packaging
 249                 COMMAND rpmbuild --define=\"%_sourcedir ${PROJECT_PKG_ENTRY_POINT}\" -ba  ${PROJECT_PKG_ENTRY_POINT}/${NPKG_PROJECT_NAME}.spec
 250         )
 251
 252         add_custom_target(rpm DEPENDS ${NPKG_PROJECT_NAME}.spec)
 253         add_dependencies(rpm populate packaging)
 254         set(ADDITIONAL_MAKE_CLEAN_FILES, "${PROJECT_NAME}.spec")
 255
 256         if(PACKAGE_MESSAGE)
 257         add_custom_command(TARGET rpm
 258                 POST_BUILD
 259                 COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --cyan "++ ${PACKAGE_MESSAGE}")
 260         endif()
 261 endmacro(rpm_package_build)
 262
 263 macro(deb_package_build)
 264 #TODO
 265 endmacro(deb_package_build)
 266
 267 macro(project_package_build)
 268         if(EXISTS ${RPM_TEMPLATE_DIR})
 269                 rpm_package_build()
 270         endif()
 271
 272         if(EXISTS ${WGT_TEMPLATE_DIR})
 273                 wgt_package_build()
 274         endif()
 275
 276         if(EXISTS ${DEB_TEMPLATE_DIR})
 277                 deb_package_build()
 278         endif()
 279 endmacro(project_package_build)
 280
 281 macro(project_subdirs_add)
 282         set (ARGSLIST ${ARGN})
 283         list(LENGTH ARGSLIST ARGSNUM)
 284         if(${ARGSNUM} GREATER 0)
 285                 file(GLOB filelist "${ARGV0}")
 286         else()
 287         file(GLOB filelist "*")
 288         endif()
 289
 290         foreach(filename ${filelist})
 291                 if(EXISTS "${filename}/CMakeLists.txt")
 292                         add_subdirectory(${filename})
 293                 endif(EXISTS "${filename}/CMakeLists.txt")
 294         endforeach()
 295 endmacro(project_subdirs_add)
 296
 297 set(CMAKE_BUILD_TYPE Debug CACHE STRING "the type of build")
 298 set(CMAKE_POSITION_INDEPENDENT_CODE ON)
 299 set(CMP0048 1)
 300
 301 # Include project configuration
 302 # ------------------------------
 303 project(${PROJECT_NAME} VERSION ${PROJECT_VERSION} LANGUAGES ${PROJECT_LANGUAGES})
 304 set(PROJECT_LIBDIR "${CMAKE_SOURCE_DIR}/libs" CACHE PATH "Subpath to libraries")
 305 set(PROJECT_RESOURCES "${CMAKE_SOURCE_DIR}/data" CACHE PATH "Subpath to data")
 306
 307 set(AFB_TOKEN   ""      CACHE PATH "Default AFB_TOKEN")
 308 set(AFB_REMPORT "1234" CACHE PATH "Default AFB_TOKEN")
 309
 310 INCLUDE(FindPkgConfig)
 311 INCLUDE(CheckIncludeFiles)
 312 INCLUDE(CheckLibraryExists)
 313 INCLUDE(GNUInstallDirs)
 314
 315 # Default compilation options
 316 ############################################################################
 317 link_libraries(-Wl,--as-needed -Wl,--gc-sections)
 318 add_compile_options(-Wall -Wextra -Wconversion)
 319 add_compile_options(-Wno-unused-parameter) # frankly not using a parameter does it care?
 320 add_compile_options(-Wno-sign-compare -Wno-sign-conversion)
 321 add_compile_options(-Werror=maybe-uninitialized)
 322 add_compile_options(-Werror=implicit-function-declaration)
 323 add_compile_options(-ffunction-sections -fdata-sections)
 324 add_compile_options(-fPIC)
 325 add_compile_options(-g)
 326
 327 set(CMAKE_C_FLAGS_PROFILING   "-g -O2 -pg -Wp,-U_FORTIFY_SOURCE" CACHE STRING "Flags for profiling")
 328 set(CMAKE_C_FLAGS_DEBUG       "-g -O2 -ggdb -Wp,-U_FORTIFY_SOURCE" CACHE STRING "Flags for debugging")
 329 set(CMAKE_C_FLAGS_RELEASE     "-O2" CACHE STRING "Flags for releasing")
 330 set(CMAKE_C_FLAGS_CCOV        "-g -O2 --coverage" CACHE STRING "Flags for coverage test")
 331
 332 set(CMAKE_CXX_FLAGS_PROFILING    "-g -O0 -pg -Wp,-U_FORTIFY_SOURCE")
 333 set(CMAKE_CXX_FLAGS_DEBUG        "-g -O0 -ggdb -Wp,-U_FORTIFY_SOURCE")
 334 set(CMAKE_CXX_FLAGS_RELEASE      "-g -O2")
 335 set(CMAKE_CXX_FLAGS_CCOV "-g -O2 --coverage")
 336
 337 # Env variable overload default
 338 if(DEFINED ENV{INSTALL_PREFIX})
 339         set (INSTALL_PREFIX $ENV{INSTALL_PREFIX})
 340 else()
 341         set(INSTALL_PREFIX "${CMAKE_SOURCE_DIR}/Install" CACHE PATH "The path where to install")
 342 endif()
 343 set(CMAKE_INSTALL_PREFIX ${INSTALL_PREFIX} CACHE STRING "Installation Prefix")
 344
 345 # (BUG!!!) as PKG_CONFIG_PATH does not work [should be en env variable]
 346 set(PKG_CONFIG_USE_CMAKE_PREFIX_PATH ON CACHE BOOLEAN "Flag for using prefix path")
 347
 348 # Loop on required package and add options
 349 foreach (PKG_CONFIG ${PKG_REQUIRED_LIST})
 350         string(REGEX REPLACE "[<>]?=.*$" "" XPREFIX ${PKG_CONFIG})
 351         PKG_CHECK_MODULES(${XPREFIX} REQUIRED ${PKG_CONFIG})
 352
 353         INCLUDE_DIRECTORIES(${${XPREFIX}_INCLUDE_DIRS})
 354         list (APPEND link_libraries ${${XPREFIX}_LDFLAGS})
 355         add_compile_options (${${XPREFIX}_CFLAGS})
 356 endforeach(PKG_CONFIG)
 357
 358 # Optional LibEfence Malloc debug library
 359 IF(CMAKE_BUILD_TYPE MATCHES DEBUG)
 360 CHECK_LIBRARY_EXISTS(efence malloc "" HAVE_LIBEFENCE)
 361 IF(HAVE_LIBEFENCE)
 362         MESSAGE(STATUS "Linking with ElectricFence for debugging purposes...")
 363         SET(libefence_LIBRARIES "-lefence")
 364         list (APPEND link_libraries ${libefence_LIBRARIES})
 365 ENDIF(HAVE_LIBEFENCE)
 366 ENDIF(CMAKE_BUILD_TYPE MATCHES DEBUG)
 367
 368 # set default include directories
 369 INCLUDE_DIRECTORIES(${EXTRA_INCLUDE_DIRS})
 370
 371 # If no install dir try to guess some smart default
 372 if(BINDINGS_INSTALL_PREFIX)
 373         set(BINDINGS_INSTALL_DIR ${BINDINGS_INSTALL_PREFIX}/${PROJECT_NAME} CACHE PATH "Where the binding will be installed in your system")
 374 else()
 375         set(BINDINGS_INSTALL_DIR ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME} CACHE PATH "Where the binding will be installed in your system")
 376 endif()
 377
 378 set(PKGOUT_DIR package CACHE PATH "Output directory for packages")
 379
 380 # Define a default package directory
 381 if(PKG_PREFIX)
 382         set(PROJECT_PKG_BUILD_DIR ${PKG_PREFIX}/${PKGOUT_DIR} CACHE PATH "Application contents to be packaged")
 383 else()
 384         set(PROJECT_PKG_BUILD_DIR ${CMAKE_CURRENT_BINARY_DIR}/${PKGOUT_DIR} CACHE PATH "Application contents to be packaged")
 385 endif()
 386
 387 set (PKG_TEMPLATE_PREFIX ${CMAKE_SOURCE_DIR}/${PROJECT_APP_TEMPLATES_DIR} CACHE PATH "Default Package Templates Directory")
 388 set(SSH_TEMPLATE_DIR "${PKG_TEMPLATE_PREFIX}/ssh" CACHE PATH "Subpath to a directory where are stored needed files to launch on remote target to debuging purposes")
 389 set(GDB_TEMPLATE_DIR "${PKG_TEMPLATE_PREFIX}/gdb" CACHE PATH "Subpath to a directory where are stored needed files to launch debuging server on a remote target. Use gdbserver.")
 390 set(WGT_TEMPLATE_DIR "${PKG_TEMPLATE_PREFIX}/wgt" CACHE PATH "Subpath to a directory where are stored needed files to build widget")
 391 if(NOT WIDGET_CONFIG_TEMPLATE)
 392         set(WIDGET_CONFIG_TEMPLATE ${WGT_TEMPLATE_DIR}/config.xml.in CACHE PATH "Path to widget config file template (config.xml.in)")
 393 endif()
 394 set(RPM_TEMPLATE_DIR "${PKG_TEMPLATE_PREFIX}/rpm" CACHE PATH "Subpath to a directory where are stored needed files to build rpm package")
 395 set(DEB_TEMPLATE_DIR "${PKG_TEMPLATE_PREFIX}/deb" CACHE PATH "Subpath to a directory where are stored needed files to build deb package")
 396
 397 string(REGEX REPLACE "^(.*)/.*$" "\\1" ENTRY_POINT "${PKG_TEMPLATE_PREFIX}")
 398 set(PROJECT_PKG_ENTRY_POINT ${ENTRY_POINT}/packaging CACHE PATH "Where package build files, like rpm.spec file or config.xml, are write.")
 399
 400 # Default Linkflag
 401 if(NOT BINDINGS_LINK_FLAG)
 402         set(BINDINGS_LINK_FLAG "-Wl,--version-script=${PKG_TEMPLATE_PREFIX}/cmake/export.map")
 403 endif()
 404
 405 # Add a dummy target to enable global dependency order
 406 # -----------------------------------------------------
 407 if(EXTRA_DEPENDENCIES_ORDER)
 408         set(DEPENDENCIES_TARGET ${PROJECT_NAME}_extra_dependencies)
 409         add_custom_target(${DEPENDENCIES_TARGET} ALL
 410                 DEPENDS ${EXTRA_DEPENDENCY_ORDER}
 411         )
 412 endif()
 413
 414 # Print developer helper message when build is done
 415 # -------------------------------------------------------
 416 macro(project_closing_msg)
 417         get_property(PROJECT_TARGETS_SET GLOBAL PROPERTY PROJECT_TARGETS SET)
 418         get_property(PROJECT_TARGETS GLOBAL PROPERTY PROJECT_TARGETS)
 419         if(CLOSING_MESSAGE AND ${PROJECT_TARGETS_SET})
 420                 add_custom_target(${PROJECT_NAME}_build_done ALL
 421                         COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --cyan "++ ${CLOSING_MESSAGE}"
 422                 )
 423                  add_dependencies(${PROJECT_NAME}_build_done
 424                         ${DEPENDENCIES_TARGET} ${PROJECT_TARGETS})
 425         endif()
 426 endmacro()
 427
 428 # Add RSYNCTARGET
 429 remote_targets_populate()
 430
 431 #Archive project
 432 set(ARCHIVE_OUTPUT_ARCHIVE ${PROJECT_PKG_ENTRY_POINT}/${NPKG_PROJECT_NAME}_${PROJECT_VERSION}.orig.tar)
 433 set(ARCHIVE_OUTPUT ${ARCHIVE_OUTPUT_ARCHIVE}.gz)
 434 set(TMP_ARCHIVE_SUBMODULE ${PROJECT_PKG_ENTRY_POINT}/${NPKG_PROJECT_NAME}-sub)
 435 set(CMD_ARCHIVE_SUBMODULE \'git archive --verbose --prefix=${NPKG_PROJECT_NAME}-${PROJECT_VERSION}/$$path/ --format tar HEAD --output ${TMP_ARCHIVE_SUBMODULE}-$$sha1.tar\' )
 436 add_custom_command(OUTPUT  ${ARCHIVE_OUTPUT}
 437         DEPENDS ${PROJECT_TARGETS}
 438         #Create git archive of the main project
 439         COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR}\; git --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git archive --format=tar --prefix=${NPKG_PROJECT_NAME}-${PROJECT_VERSION}/ HEAD -o ${ARCHIVE_OUTPUT_ARCHIVE}
 440         #Create tmp git archive for each submodule
 441         COMMAND cd ${CMAKE_CURRENT_SOURCE_DIR}\; git --git-dir=${CMAKE_CURRENT_SOURCE_DIR}/.git submodule foreach --recursive ${CMD_ARCHIVE_SUBMODULE}
 442         #Concatenate main archive and tmp submodule archive
 443         COMMAND  for SUBTAR in ${TMP_ARCHIVE_SUBMODULE}-*.tar\; do tar --concatenate --file=${ARCHIVE_OUTPUT_ARCHIVE} $$SUBTAR\;done
 444         #Remove tmp submodule archive
 445         COMMAND rm -rf ${TMP_ARCHIVE_SUBMODULE}-*.tar
 446         #Compress main archive
 447         COMMAND gzip --force --verbose ${ARCHIVE_OUTPUT_ARCHIVE}
 448 )
 449 add_custom_target(archive DEPENDS ${ARCHIVE_OUTPUT})
 450
 451 #Get the os type
 452 if(EXISTS "/etc/os-release")
 453         execute_process(COMMAND grep ID_LIKE /etc/os-release
 454                 OUTPUT_VARIABLE TMP_OSRELEASE
 455         )
 456         if (NOT TMP_OSRELEASE STREQUAL "")
 457                 string(REGEX REPLACE ".*=" "" OSRELEASE ${TMP_OSRELEASE})
 458         else()
 459                 set(OSRELEASE "NOT DEBIAN OS")
 460         endif()
 461         message(STATUS "OSRELEASE = ${OSRELEASE}")
 462 else()
 463         set(OSRELEASE "NOT DEBIAN OS")
 464 endif()
 465
 466         #Format Build require package
 467         foreach (PKG_CONFIG ${PKG_REQUIRED_LIST})
 468                 #Unset TMP variable
 469                 unset(XPREFIX)
 470                 unset(XRULE)
 471                 unset(RPM_EXTRA_DEP)
 472                 unset(DEB_EXTRA_DEP)
 473                 #For deb package,add EOL format only for a new line
 474                 if(DEB_PKG_DEPS)
 475                         set(DEB_PKG_DEPS "${DEB_PKG_DEPS},\n")
 476                 endif()
 477                 #Get pkg-config rule on version
 478                 string(REGEX REPLACE "[<>]?=.*$" "" XPREFIX ${PKG_CONFIG})
 479                 string(REGEX MATCH "[<>]?="  XRULE ${PKG_CONFIG})
 480                 #Only if pkg-config has rule on version
 481                 if(XRULE)
 482                         string(REGEX REPLACE ".*[<>]?=" "" XVERS ${PKG_CONFIG})
 483                         set(RPM_EXTRA_DEP " ${XRULE} ${XVERS}")
 484                         set(DEB_EXTRA_DEP " (${XRULE} ${XVERS})")
 485                 endif()
 486                 #Format for rpm package
 487                 set(RPM_PKG_DEPS "${RPM_PKG_DEPS}BuildRequires: pkgconfig(${XPREFIX})${RPM_EXTRA_DEP}\n")
 488                 #Format for deb package
 489                 #Because the tool "dpkg" is used on the packages db to find the
 490                 #package providing the pkg-cong file ${XPREFIX}.pc, we need
 491                 #to test the OS release package type
 492                 if( OSRELEASE MATCHES "debian" )
 493                         execute_process(
 494                                 COMMAND dpkg -S *${XPREFIX}.pc
 495                                                 OUTPUT_VARIABLE TMP_PKG_BIN
 496                                                 )
 497                         #Need to be harden check
 498                         string(REGEX REPLACE ":.*$" "" PKG_BIN ${TMP_PKG_BIN})
 499                         set(DEB_PKG_DEPS "${DEB_PKG_DEPS} ${PKG_BIN} ${DEB_EXTRA_DEP}")
 500                 endif()
 501         endforeach()
 502
 503         if(NOT EXISTS ${RPM_TEMPLATE_DIR}/rpm-config.spec.in)
 504                 MESSAGE(FATAL_ERROR "${Red}Missing mandatory files: you need rpm-config.spec.in in ${RPM_TEMPLATE_DIR} folder.${ColourReset}")
 505         endif()
 506         set(PACKAGING_SPEC_OUTPUT ${PROJECT_PKG_ENTRY_POINT}/${NPKG_PROJECT_NAME}.spec)
 507 add_custom_command(OUTPUT ${PACKAGING_SPEC_OUTPUT}
 508         COMMAND ${CMAKE_COMMAND} -DINFILE=${RPM_TEMPLATE_DIR}/rpm-config.spec.in -DOUTFILE=${PACKAGING_SPEC_OUTPUT} -DPROJECT_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR} -P ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_APP_TEMPLATES_DIR}/cmake/configure_file.cmake
 509         )
 510
 511 #Because the tool "dpkg" is used on the packages db to find the
 512 #package providing the pkg-cong file ${XPREFIX}.pc, we need
 513 #to test the OS release package type
 514 if(OSRELEASE MATCHES "debian")
 515         # build deb spec file from template
 516         set(PACKAGING_DEB_OUTPUT_DSC       ${PROJECT_PKG_ENTRY_POINT}/${NPKG_PROJECT_NAME}.dsc)
 517         set(PACKAGING_DEB_OUTPUT_INSTALL   ${PROJECT_PKG_ENTRY_POINT}/debian.${NPKG_PROJECT_NAME}.install)
 518         set(PACKAGING_DEB_OUTPUT_CHANGELOG ${PROJECT_PKG_ENTRY_POINT}/debian.changelog)
 519         set(PACKAGING_DEB_OUTPUT_COMPAT    ${PROJECT_PKG_ENTRY_POINT}/debian.compat)
 520         set(PACKAGING_DEB_OUTPUT_CONTROL   ${PROJECT_PKG_ENTRY_POINT}/debian.control)
 521         set(PACKAGING_DEB_OUTPUT_RULES     ${PROJECT_PKG_ENTRY_POINT}/debian.rules)
 522         add_custom_command(OUTPUT ${PACKAGING_DEB_OUTPUT_DSC}
 523                                 ${PACKAGING_DEB_OUTPUT_INSTALL}
 524                                 ${PACKAGING_DEB_OUTPUT_CHANGELOG}
 525                                 ${PACKAGING_DEB_OUTPUT_COMPAT}
 526                                 ${PACKAGING_DEB_OUTPUT_CONTROL}
 527                                 ${PACKAGING_DEB_OUTPUT_RULES}
 528                                 COMMAND ${CMAKE_COMMAND} -DINFILE=${DEB_TEMPLATE_DIR}/debian.compat.in          -DOUTFILE=${PACKAGING_DEB_OUTPUT_COMPAT}        -DPROJECT_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}        -P      ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_APP_TEMPLATES_DIR}/cmake/configure_file.cmake
 529                                 COMMAND ${CMAKE_COMMAND} -DINFILE=${DEB_TEMPLATE_DIR}/debian.changelog.in       -DOUTFILE=${PACKAGING_DEB_OUTPUT_CHANGELOG}     -DPROJECT_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}        -P      ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_APP_TEMPLATES_DIR}/cmake/configure_file.cmake
 530                                 COMMAND ${CMAKE_COMMAND} -DINFILE=${DEB_TEMPLATE_DIR}/deb-config.dsc.in         -DOUTFILE=${PACKAGING_DEB_OUTPUT_DSC}           -DPROJECT_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}        -P      ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_APP_TEMPLATES_DIR}/cmake/configure_file.cmake
 531                                 COMMAND ${CMAKE_COMMAND} -DINFILE=${DEB_TEMPLATE_DIR}/deb-config.install.in     -DOUTFILE=${PACKAGING_DEB_OUTPUT_INSTALL}       -DPROJECT_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}        -P      ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_APP_TEMPLATES_DIR}/cmake/configure_file.cmake
 532                                 COMMAND ${CMAKE_COMMAND} -DINFILE=${DEB_TEMPLATE_DIR}/debian.control.in         -DOUTFILE=${PACKAGING_DEB_OUTPUT_CONTROL}       -DPROJECT_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}        -P      ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_APP_TEMPLATES_DIR}/cmake/configure_file.cmake
 533                                 COMMAND ${CMAKE_COMMAND} -DINFILE=${DEB_TEMPLATE_DIR}/debian.rules.in           -DOUTFILE=${PACKAGING_DEB_OUTPUT_RULES}         -DPROJECT_BINARY_DIR=${CMAKE_CURRENT_BINARY_DIR}        -P      ${CMAKE_CURRENT_SOURCE_DIR}/${PROJECT_APP_TEMPLATES_DIR}/cmake/configure_file.cmake
 534         )
 535         add_custom_target(packaging_deb DEPENDS ${PACKAGING_DEB_OUTPUT_DSC}
 536                                                 ${PACKAGING_DEB_OUTPUT_INSTALL}
 537                                                 ${PACKAGING_DEB_OUTPUT_CHANGELOG}
 538                                                 ${PACKAGING_DEB_OUTPUT_COMPAT}
 539                                                 ${PACKAGING_DEB_OUTPUT_CONTROL}
 540                                                 ${PACKAGING_DEB_OUTPUT_CONTROL}
 541                                                 ${PACKAGING_DEB_OUTPUT_RULES})
 542 endif()
 543
 544 add_custom_target(packaging)
 545 add_custom_target(packaging_rpm DEPENDS ${PACKAGING_SPEC_OUTPUT})
 546 add_dependencies(packaging packaging_rpm)
 547 if(TARGET packaging_wgt)
 548         add_dependencies(packaging packaging_wgt)
 549 endif()
 550 if(OSRELEASE MATCHES "debian")
 551         # Target to add dependencies indirectly to "packaging" target.
 552         add_dependencies(packaging packaging_deb)
 553 endif()
 554
 555 #Generate a cmake cache file usable by cmake script.
 556 set(CacheForScript ${CMAKE_BINARY_DIR}/CMakeCacheForScript.cmake)
 557 #Create a tmp cmake file.
 558 file(WRITE ${CacheForScript} "")
 559
 560 get_cmake_property(Vars VARIABLES)
 561 foreach(Var ${Vars})
 562         if(${Var})
 563                 #Replace unwanted char.
 564                 string(REPLACE "\\" "\\\\" VALUE ${${Var}})
 565                 string(REPLACE "\n" "\\n" VALUE ${VALUE})
 566                 string(REPLACE "\r" "\\n" VALUE ${VALUE})
 567                 string(REPLACE "\"" "\\\"" VALUE ${VALUE})
 568         endif()
 569
 570         file(APPEND ${CacheForScript} "set(${Var} \"${VALUE}\")\n")
 571 endforeach()