build/tizen/CMakeLists.txt

   1 CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
   2 CMAKE_POLICY(SET CMP0012 NEW) # Prevent dereferencing of OFF/ON as variables
   3
   4 SET(name "dali-toolkit")
   5
   6 PROJECT(${name})
   7 SET(PKG_NAME ${name})
   8
   9 SET(GCC_COMPILER_VERSION_REQUIRED "6")
  10 if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
  11   if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS GCC_COMPILER_VERSION_REQUIRED)
  12     message(FATAL_ERROR "The GCC required compiler version is " ${GCC_COMPILER_VERSION_REQUIRED})
  13   endif()
  14 endif()
  15
  16 FIND_PACKAGE( PkgConfig REQUIRED )
  17 FIND_PACKAGE( Doxygen QUIET )
  18
  19 PKG_CHECK_MODULES(DALICORE REQUIRED dali-core)
  20 PKG_CHECK_MODULES(DALIADAPTOR REQUIRED dali-adaptor)
  21
  22 # API VERSION (Not DALi release version)
  23 SET(${name}_VERSION_MAJOR 0)
  24 SET(${name}_VERSION_MINOR 0)
  25 SET(${name}_VERSION_PATCH 0)
  26 SET(${name}_VERSION ${${name}_VERSION_MAJOR}.${${name}_VERSION_MINOR}.${${name}_VERSION_PATCH} )
  27
  28 SET(DALI_TOOLKIT_VERSION ${${name}_VERSION} )
  29
  30 # Define options to CMake
  31 OPTION(ENABLE_EXPORTALL      "Enable Export all symbols" OFF)
  32 OPTION(ENABLE_DEBUG          "Enable Debug" OFF)
  33 OPTION(ENABLE_TRACE          "Enable Trace" OFF)
  34 OPTION(ENABLE_I18N           "Turns on internationalisation" OFF)
  35 OPTION(ENABLE_COVERAGE       "Coverage" OFF)
  36
  37 # Define non-boolean options to CMake
  38 SET(WITH_STYLE               "480x800" CACHE STRING "Select the style folder to use")
  39
  40 # from root/build/tizen, get back to root
  41 SET(ROOT_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../../)
  42
  43 # Make sure the path is absolute
  44 GET_FILENAME_COMPONENT(ROOT_SRC_DIR ${ROOT_SRC_DIR} ABSOLUTE)
  45
  46 # Set DALi style
  47 SET( dali_style ${WITH_STYLE} )
  48
  49 # Style folder
  50 SET( STYLE_BASE_DIR ${ROOT_SRC_DIR}/dali-toolkit/styles )
  51 SET( STYLE_DIR ${STYLE_BASE_DIR}/${dali_style} )
  52
  53 SET( toolkit_styles_base_dir ${STYLE_BASE_DIR} )
  54 SET( toolkit_styles_dir ${STYLE_DIR} )
  55 SET( toolkit_style_images_dir ${STYLE_DIR}/images )
  56
  57 IF( DEFINED ENV{DALI_DATA_RW_DIR} )
  58   SET( dataReadWriteDir $ENV{DALI_DATA_RW_DIR} )
  59 ELSE()
  60   SET( dataReadWriteDir ${CMAKE_INSTALL_PREFIX}/share/dali/ )
  61 ENDIF()
  62
  63 IF( DEFINED ENV{DALI_DATA_RO_DIR} )
  64   SET( dataReadOnlyDir $ENV{DALI_DATA_RO_DIR} )
  65 ELSE()
  66   SET( dataReadOnlyDir ${CMAKE_INSTALL_PREFIX}/share/dali/ )
  67 ENDIF()
  68
  69 # Set up compiler definitions
  70 IF(CMAKE_BUILD_TYPE MATCHES Debug)
  71   MESSAGE( STATUS "CMAKE_BUILD_TYPE: " Debug )
  72   SET( ENABLE_DEBUG ON )
  73 ELSE()
  74   MESSAGE( STATUS "CMAKE_BUILD_TYPE: " Release )
  75 ENDIF()
  76
  77 ADD_DEFINITIONS(-DPIC -DSTDC_HEADERS)
  78 ADD_DEFINITIONS(-DDALI_IMAGE_DIR=\"${dataReadOnlyDir}/toolkit/images/\"
  79                 -DDALI_SOUND_DIR=\"${dataReadOnlyDir}/toolkit/sounds/\"
  80                 -DDALI_STYLE_DIR=\"${dataReadOnlyDir}/toolkit/styles/\"
  81                 -DDALI_STYLE_IMAGE_DIR=\"${dataReadOnlyDir}/toolkit/styles/images/\"
  82                 -DDALI_DATA_READ_ONLY_DIR=\"${dataReadOnlyDir}\" )
  83
  84 IF("${ARCH}" STREQUAL "arm")
  85   ADD_DEFINITIONS("-DTARGET")
  86 ENDIF("${ARCH}" STREQUAL "arm")
  87
  88 IF( ENABLE_DEBUG )
  89   ADD_DEFINITIONS( "-DDEBUG_ENABLED" )
  90   SET( ENABLE_EXPORTALL ON )
  91 ENDIF( ENABLE_DEBUG )
  92
  93 IF( NOT ${ENABLE_EXPORTALL} )
  94   ADD_DEFINITIONS( "-fvisibility=hidden -DHIDE_DALI_INTERNALS" )
  95 ENDIF( NOT ${ENABLE_EXPORTALL} )
  96
  97 IF( ENABLE_I18N )
  98   ADD_DEFINITIONS( "-DDGETTEXT_ENABLED" )
  99 ENDIF( ENABLE_I18N )
 100
 101 # Platforms with highp shader support can use vector based text
 102 IF( "${PROFILE}" STREQUAL "UBUNTU" )
 103   SET( ENABLE_VECTOR_BASED_TEXT_RENDERING 1 )
 104 ENDIF()
 105
 106 # Deployment folder should come from spec file or command line:
 107 SET( PREFIX ${CMAKE_INSTALL_PREFIX})
 108 SET( EXEC_PREFIX ${CMAKE_INSTALL_PREFIX})
 109
 110 # Set paths
 111 SET( toolkit_images_dir  ${ROOT_SRC_DIR}/dali-toolkit/styles/images-common )
 112 SET( toolkit_sounds_dir  ${ROOT_SRC_DIR}/dali-toolkit/sounds )
 113 SET( toolkit_src_dir     ${ROOT_SRC_DIR}/dali-toolkit/internal )
 114 SET( public_api_src_dir  ${ROOT_SRC_DIR}/dali-toolkit/public-api )
 115 SET( devel_api_src_dir   ${ROOT_SRC_DIR}/dali-toolkit/devel-api )
 116 SET( third_party_src_dir ${ROOT_SRC_DIR}/dali-toolkit/third-party )
 117 SET( package_doxy_dir    ${ROOT_SRC_DIR}/doc )
 118
 119 # Set up the include dir
 120 SET( INCLUDE_DIR $ENV{includedir} )
 121 IF( NOT INCLUDE_DIR )
 122   SET( INCLUDE_DIR ${CMAKE_INSTALL_INCLUDEDIR} )
 123 ENDIF()
 124 IF( NOT INCLUDE_DIR )
 125   SET( INCLUDE_DIR ${PREFIX}/include )
 126 ENDIF()
 127
 128 # Set up the lib dir
 129 SET( LIB_DIR $ENV{libdir} )
 130 IF( NOT LIB_DIR )
 131   SET( LIB_DIR ${CMAKE_INSTALL_LIBDIR} )
 132 ENDIF()
 133 IF( NOT LIB_DIR )
 134   SET( LIB_DIR ${PREFIX}/lib )
 135 ENDIF()
 136
 137 # Configure the pkg-config file
 138 # Requires the following variables to be setup:
 139 # @PREFIX@ @EXEC_PREFIX@ @DALI_VERSION@ @LIB_DIR@ @DEV_INCLUDE_PATH@
 140 SET( DEV_INCLUDE_PATH ${INCLUDE_DIR} )
 141 SET( CORE_PKG_CFG_FILE dali-toolkit.pc )
 142 CONFIGURE_FILE( ${CORE_PKG_CFG_FILE}.in ${CORE_PKG_CFG_FILE} @ONLY )
 143
 144 # Set up compiler flags and warnings
 145 ADD_COMPILE_OPTIONS( -std=c++11 )
 146 ADD_COMPILE_OPTIONS( -Wno-ignored-qualifiers )
 147
 148 # TODO: Clang is a lot more strict with warnings, we should address
 149 # those issues at some point.
 150 IF( NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" )
 151   ADD_COMPILE_OPTIONS( -Werror )
 152 ENDIF()
 153
 154 ADD_COMPILE_OPTIONS( -Wall -Wno-unused-parameter -Wno-float-equal -Wno-class-memaccess )
 155
 156 IF( ENABLE_COVERAGE OR "$ENV{CXXFLAGS}" MATCHES --coverage )
 157   ADD_COMPILE_OPTIONS( --coverage )
 158   SET(ENABLE_COVERAGE ON)
 159   SET(COVERAGE --coverage)
 160 ENDIF()
 161
 162 IF( ENABLE_TRACE )
 163   ADD_DEFINITIONS("-DTRACE_ENABLED")
 164 ENDIF()
 165
 166 INCLUDE_DIRECTORIES(
 167   ${ROOT_SRC_DIR}
 168   ${DALICORE_INCLUDE_DIRS}
 169   ${DALIADAPTOR_INCLUDE_DIRS}
 170 )
 171
 172 SET(SOURCE_DIR "${ROOT_SRC_DIR}/dali")
 173 SET(PACKAGE_DOXY_SRC_DIR "${ROOT_SRC_DIR}/doc")
 174
 175 SET(SOURCES "")
 176
 177 # could use INCLUDE to get the source lists a different way;
 178 # would then need to specify a build folder somehow...
 179 INCLUDE( ${ROOT_SRC_DIR}/dali-toolkit/sounds/file.list )
 180 INCLUDE( ${ROOT_SRC_DIR}/dali-toolkit/styles/file.list )
 181 INCLUDE( ${ROOT_SRC_DIR}/dali-toolkit/styles/images-common/file.list )
 182 INCLUDE( ${ROOT_SRC_DIR}/dali-toolkit/internal/file.list )
 183 INCLUDE( ${ROOT_SRC_DIR}/dali-toolkit/public-api/file.list )
 184 INCLUDE( ${ROOT_SRC_DIR}/dali-toolkit/devel-api/file.list )
 185 INCLUDE( ${ROOT_SRC_DIR}/dali-toolkit/third-party/file.list )
 186 INCLUDE( ${ROOT_SRC_DIR}/doc/file.list )
 187
 188 SET(LIBTYPE SHARED)
 189 IF(DEFINED STATIC)
 190   SET(LIBTYPE STATIC)
 191 ENDIF()
 192
 193 ADD_LIBRARY( ${name} ${LIBTYPE} ${SOURCES} )
 194 TARGET_LINK_LIBRARIES( ${name}
 195   ${DALICORE_LDFLAGS}
 196   ${DALIADAPTOR_LDFLAGS}
 197   ${COVERAGE}
 198 )
 199 IF( ANDROID )
 200 TARGET_LINK_LIBRARIES( ${name} log )
 201 ENDIF()
 202
 203 SET_TARGET_PROPERTIES( ${name}
 204   PROPERTIES
 205   VERSION ${DALI_TOOLKIT_VERSION}
 206   SOVERSION ${${name}_VERSION_MAJOR}
 207   CLEAN_DIRECT_OUPUT 1
 208 )
 209
 210 # Install the library so file and symlinks
 211 INSTALL( TARGETS ${name} DESTINATION ${LIB_DIR} )
 212
 213 # Install the pkg-config file
 214 INSTALL( FILES ${CMAKE_CURRENT_BINARY_DIR}/${CORE_PKG_CFG_FILE} DESTINATION ${LIB_DIR}/pkgconfig )
 215
 216 # Glob for resources
 217 MACRO( COPY_RESOURCES FILE_LIST SRC_RELATIVE_DIRECTORY DESTINATION EXPLICIT_DESTINATION )
 218   FOREACH( PATTERN ${FILE_LIST} )
 219     FILE(GLOB FILES ${PATTERN} )
 220     FOREACH( FILE ${FILES} )
 221       STRING(REPLACE ${SRC_RELATIVE_DIRECTORY} ${DESTINATION} NEWFILE ${FILE} )
 222       GET_FILENAME_COMPONENT(NEWDIR ${NEWFILE} DIRECTORY)
 223       IF( "${EXPLICIT_DESTINATION}" STREQUAL "" )
 224         STRING( REPLACE "dali-toolkit" "toolkit" NEWDIR2 ${NEWDIR} )
 225         INSTALL( FILES ${FILE} DESTINATION ${NEWDIR2} )
 226       ELSE()
 227         INSTALL( FILES ${FILE} DESTINATION ${DESTINATION}/${EXPLICIT_DESTINATION} )
 228       ENDIF()
 229     ENDFOREACH()
 230   ENDFOREACH()
 231 ENDMACRO()
 232
 233 # macro for installing headers by replacing prefix. (TODO, investigate
 234 # if there is a CMAKE way of doing this automatically)
 235 MACRO(INSTALL_HEADERS_WITH_DIRECTORY HEADER_LIST STRIP_PREFIX REPLACE_PREFIX)
 236   GET_FILENAME_COMPONENT( SPREFIX ${STRIP_PREFIX} ABSOLUTE )
 237   FOREACH(HEADER ${${HEADER_LIST}})
 238     STRING(REGEX MATCH "(.*)[/]" DIR ${HEADER})
 239     STRING(REPLACE ${SPREFIX} ${REPLACE_PREFIX} NEWDIR ${DIR})
 240     INSTALL(FILES ${HEADER} DESTINATION ${INCLUDE_DIR}/${NEWDIR})
 241   ENDFOREACH(HEADER)
 242 ENDMACRO(INSTALL_HEADERS_WITH_DIRECTORY)
 243
 244 # Install headers using lists defined by ADD_SUBDIRECTORY
 245 INSTALL_HEADERS_WITH_DIRECTORY(PUBLIC_API_HEADERS ${ROOT_SRC_DIR}/dali-toolkit "dali-toolkit")
 246 INSTALL_HEADERS_WITH_DIRECTORY(DEVEL_API_HEADERS ${ROOT_SRC_DIR}/dali-toolkit "dali-toolkit")
 247 INSTALL_HEADERS_WITH_DIRECTORY(INTEGRATION_API_HEADERS ${ROOT_SRC_DIR}/dali-toolkit "dali-toolkit")
 248 INSTALL_HEADERS_WITH_DIRECTORY(PACKAGE_DOXY_HEADERS ${PACKAGE_DOXY_SRC_DIR} "dali-toolkit/doc" )
 249
 250 # Install dali-toolkit.h
 251 INSTALL( FILES ${ROOT_SRC_DIR}/dali-toolkit/dali-toolkit.h DESTINATION ${DEV_INCLUDE_PATH}/dali-toolkit )
 252
 253 # package doxygen file (contains doxygen grouping information)
 254 INSTALL( FILES ${package_doxy_files} DESTINATION ${DEV_INCLUDE_PATH}/dali-toolkit/doc )
 255
 256 # On some platforms we want to install the data files to different location compare to
 257 # the data location used runtime. For example, on Android we want the toolkit library to load
 258 # the files from /data/data/com.sec.dali_demo/files but to install the files into ${PREFIX}/files
 259 # for SDK to pick them up for the archive.
 260 IF( DEFINED ENV{DALI_DATA_RW_INSTALL_DIR} )
 261   SET( dataReadWriteInstallDir $ENV{DALI_DATA_RW_INSTALL_DIR} )
 262 ELSE()
 263   SET( dataReadWriteInstallDir ${dataReadWriteDir} )
 264 ENDIF()
 265
 266 IF( DEFINED ENV{DALI_DATA_RO_INSTALL_DIR} )
 267   SET( dataReadOnlyInstallDir $ENV{DALI_DATA_RO_INSTALL_DIR} )
 268 ELSE()
 269   SET( dataReadOnlyInstallDir ${dataReadOnlyDir} )
 270 ENDIF()
 271
 272 COPY_RESOURCES( "${dali_toolkit_style_files}" "${ROOT_SRC_DIR}" "${dataReadOnlyInstallDir}" "./toolkit/styles" )
 273 COPY_RESOURCES( "${dali_toolkit_image_files}" "${ROOT_SRC_DIR}" "${dataReadOnlyInstallDir}" "./toolkit/images" )
 274 COPY_RESOURCES( "${dali_toolkit_sound_files}" "${ROOT_SRC_DIR}" "${dataReadOnlyInstallDir}" "./toolkit/sounds" )
 275 COPY_RESOURCES( "${dali_toolkit_style_images}" "${ROOT_SRC_DIR}" "${dataReadOnlyInstallDir}" "./toolkit/styles/images" )
 276
 277 # The DALI_TOOLKIT_PREFIX must be set if this CMakeLists.txt is executed
 278 # from the top-level CMake script using ADD_SUBDIRECTORY() to avoid
 279 # target names duplication with other DALi modules.
 280 IF( UNIX )
 281   FIND_PROGRAM( LCOV_BIN "lcov" )
 282   IF( LCOV_BIN )
 283
 284     # Define custom rules for coverage
 285     SET(COVERAGE_DIR .cov)
 286     SET(COVERAGE_OUTPUT_DIR doc/coverage)
 287
 288     # lcov prior to 1.10 doesn't have -rc option; this and subsequent version don't output
 289     # branch coverage. Determine the lcov version, and enable branch coverage accordingly.
 290     EXECUTE_PROCESS( COMMAND bash -c "${LCOV_BIN} --version | cut -d' ' -f4" OUTPUT_VARIABLE LCOV_VERSION )
 291     STRING( REPLACE "." ";" LCOV_VLIST ${LCOV_VERSION})
 292     IF( NOT $<VERSION_LESS:${LCOV_VERSION},"1.10"> )
 293       SET(LCOV_OPTS --rc lcov_branch_coverage=1)
 294     ENDIF()
 295
 296     ADD_CUSTOM_TARGET( ${DALI_TOOLKIT_PREFIX}rename_cov_data ./rename-cov-data )
 297
 298     ADD_CUSTOM_TARGET( ${DALI_TOOLKIT_PREFIX}cov_data ${LCOV_BIN} ${LCOV_OPTS} --base-directory . --directory . -c -o dali.info
 299       COMMAND ${LCOV_BIN} ${LCOV_OPTS} --remove dali.info \"*/dali-env/*\" \"/usr/include/*\" "*/dali-env/*" "*solid-color-actor*" "*/dali-toolkit/third-party/*" -o dali.info )
 300
 301     ADD_CUSTOM_TARGET( ${DALI_TOOLKIT_PREFIX}coverage genhtml ${LCOV_OPTS} -o ${COVERAGE_OUTPUT_DIR} dali.info
 302       DEPENDS cov_data )
 303
 304     ADD_CUSTOM_TARGET( ${DALI_TOOLKIT_PREFIX}reset_coverage @${LCOV_BIN} -z --directory `pwd` )
 305
 306     # Define custom rule for distclean
 307     ADD_CUSTOM_TARGET( ${DALI_TOOLKIT_PREFIX}distclean @echo cleaning for source distribution )
 308     ADD_CUSTOM_COMMAND(
 309           DEPENDS ${DALI_TOOLKIT_PREFIX}clean
 310           COMMENT "distribution clean"
 311           COMMAND find
 312           ARGS    .
 313           -not -name config.cmake -and \(
 314           -name tester.c -or
 315           -name Testing -or
 316           -name CMakeFiles -or
 317           -name doc -or
 318           -name cmake.depends -or
 319           -name cmake.check_depends -or
 320           -name CMakeCache.txt -or
 321           -name cmake.check_cache -or
 322           -name *.cmake -or
 323           -name Makefile -or
 324           -name core -or
 325           -name core.* -or
 326           -name gmon.out -or
 327           -name install_manifest.txt -or
 328           -name *.pc -or
 329           -name *.gcov -or
 330           -name *.gcno -or
 331           -name *.gcda -or
 332           -name *~ -or
 333           -name libdali*.so* \)
 334           | grep -v TC | xargs rm -rf
 335           TARGET  ${DALI_TOOLKIT_PREFIX}distclean
 336           VERBATIM
 337           )
 338
 339   ENDIF( LCOV_BIN )
 340 ENDIF( UNIX )
 341
 342 # Build documentation if doxygen tool is available
 343 SET( doxygenEnabled OFF )
 344 IF( DOXYGEN_FOUND )
 345   SET( doxygenEnabled ON )
 346   # 'prefix' is used by doxygen in-files.
 347   SET( prefix ${PREFIX} )
 348   SET( DOXYGEN_DOCS_DIR ${ROOT_SRC_DIR}/docs )
 349   SET( DOXYGEN_ROOT_DIR ${ROOT_SRC_DIR} )
 350   SET( DOXYGEN_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/docs )
 351   SET( DOXYGEN_INTERNAL_SRC_DIR ${CMAKE_CURRENT_SOURCE_DIR}/docs-internal )
 352   CONFIGURE_FILE( ${DOXYGEN_SRC_DIR}/dali.doxy.in ${DOXYGEN_SRC_DIR}/dali.doxy @ONLY )
 353   CONFIGURE_FILE( ${DOXYGEN_INTERNAL_SRC_DIR}/dali-internal.doxy.in ${DOXYGEN_INTERNAL_SRC_DIR}/dali-internal.doxy @ONLY )
 354   ADD_CUSTOM_TARGET( doc_doxygen ALL
 355                      DEPENDS ${name}
 356                      COMMAND ${DOXYGEN_EXECUTABLE} -u ${DOXYGEN_SRC_DIR}/dali.doxy
 357                      COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_SRC_DIR}/dali.doxy
 358                      COMMAND ${CMAKE_COMMAND} -P ${DOXYGEN_SRC_DIR}/check_for_errors.cmake
 359                      COMMENT "Generating API documentation with Doxygen"
 360                      WORKING_DIRECTORY ${DOXYGEN_SRC_DIR}
 361                      VERBATIM )
 362   ADD_CUSTOM_TARGET( doc_doxygen_internal
 363                      COMMAND ${DOXYGEN_EXECUTABLE} -u ${DOXYGEN_INTERNAL_SRC_DIR}/dali-internal.doxy
 364                      COMMAND ${DOXYGEN_EXECUTABLE} ${DOXYGEN_INTERNAL_SRC_DIR}/dali-internal.doxy
 365                      COMMENT "Generating Internal API documentation with Doxygen"
 366                      VERBATIM )
 367
 368 ENDIF()
 369
 370 # Configure automated tests
 371 CONFIGURE_FILE( ${ROOT_SRC_DIR}/automated-tests/CMakeLists.txt.in
 372                 ${ROOT_SRC_DIR}/automated-tests/CMakeLists.txt @ONLY )
 373
 374 # Configuration Messages
 375 MESSAGE( STATUS "Configuration:\n" )
 376 MESSAGE( STATUS "Prefix:                        " ${PREFIX} )
 377 MESSAGE( STATUS "Lib Dir:                       " ${LIB_DIR} )
 378 MESSAGE( STATUS "Include Dir:                   " ${INCLUDE_DIR} )
 379 MESSAGE( STATUS "Debug build:                   " ${ENABLE_DEBUG} )
 380 MESSAGE( STATUS "Export all symbols:            " ${ENABLE_EXPORTALL} )
 381 MESSAGE( STATUS "Coverage:                      " ${ENABLE_COVERAGE} )
 382 MESSAGE( STATUS "Trace:                         " ${ENABLE_TRACE} )
 383 MESSAGE( STATUS "Doxygen:                       " ${doxygenEnabled} )
 384 MESSAGE( STATUS "Data Dir (Read/Write):         " ${dataReadWriteDir} )
 385 MESSAGE( STATUS "Data Dir (Read Only):          " ${dataReadOnlyDir} )
 386 MESSAGE( STATUS "Data Install Dir (Read/Write): " ${dataReadWriteInstallDir} )
 387 MESSAGE( STATUS "Data Install Dir (Read Only):  " ${dataReadOnlyInstallDir} )
 388 MESSAGE( STATUS "Style Dir:                     " ${STYLE_DIR} )
 389 MESSAGE( STATUS "Style:                         " ${dali_style} )
 390 MESSAGE( STATUS "i18n:                          " ${ENABLE_I18N} )
 391 MESSAGE( STATUS "CXXFLAGS:                      " ${CMAKE_CXX_FLAGS} )
 392 MESSAGE( STATUS "LDFLAGS:                       " ${CMAKE_SHARED_LINKER_FLAGS_INIT}${CMAKE_SHARED_LINKER_FLAGS} )