CMakeUserFindOpenTURNS

From KitwarePublic
Revision as of 13:22, 6 August 2010 by Xantares (talk | contribs)
Jump to navigationJump to search

Back

File:FindOpenTURNS.cmake

  1. -- Try to find OpenTURNS
 #
 #  OpenTURNS is an Open source initiative to Treat Uncertainties,
 #  Risks’N Statistics in a structured industrial approach,
 #  available at http://www.openturns.org/
 #
 #  ---------------------------------------------------------------------
 #
 #  -- Library usage example :
 #
 #  find_package (OpenTURNS 0.13.1)
 #  if (OPENTURNS_FOUND)
 #     include_directories (${OPENTURNS_INCLUDE_DIRS})
 #     add_executable (foo foo.cpp)
 #     target_link_libraries (foo ${OPENTURNS_LIBRARIES})
 #  endif ()
 #
 #  -- Module usage example :
 #
 #  find_package (OpenTURNS 0.13 COMPONENTS Trapezoidal)
 #  if (OPENTURNS_TRAPEZOIDAL_FOUND)
 #     include_directories (${OPENTURNS_TRAPEZOIDAL_INCLUDE_DIRS})
 #     add_executable (foo foo.cpp)
 #     target_link_libraries (foo ${OPENTURNS_TRAPEZOIDAL_LIBRARIES})
 #  endif ()
 #
 #  -- Show some debug information :
 #
 #  set (OPENTURNS_DEBUG TRUE)
 #  find_package (OpenTURNS)
 #
 #  ---------------------------------------------------------------------
 #
 #  -- This module defines :
 #
 #  OPENTURNS_FOUND - OpenTURNS is usable as a library
 #  OPENTURNS_INCLUDE_DIR - Where to find OT.hxx (not for general use)
 #  OPENTURNS_INCLUDE_DIRS - dependencies include directories
 #  OPENTURNS_SWIG_INCLUDE_DIR - Include directory to swig (.i) interface
 #  OPENTURNS_VERSION - Version string
 #  OPENTURNS_LIBRARY - Path to libOT.so (not for general use)
 #  OPENTURNS_LIBRARIES - Link these to use the library
 #  OPENTURNS_ROOT_DIR - Installation directory
 #  OPENTURNS_EXAMPLES_DIR - path to examples programs
 #
 #  OPENTURNS_WRAPPER_FOUND - OpenTURNS wrapper library is usable
 #  OPENTURNS_WRAPPER_DIR - Wrapper directory
 #  OPENTURNS_WRAPPER_LIBRARIES - Link these to use the wrapper
 #  OPENTURNS_WRAPPER_DEFINITIONS - Compiler switches required for wrapper
 #
 #  OPENTURNS_MODULE_DIR - OpenTURNS module directory
 #  OPENTURNS_MODULE_DEFINITIONS - Compiler switches required for module
 #  OPENTURNS_NAME_FOUND - True if module NAME was found
 #  OPENTURNS_NAME_INCLUDE_DIR - Module NAME headers
 #  OPENTURNS_NAME_INCLUDE_DIRS - Module NAME includes
 #  OPENTURNS_NAME_SWIG_INCLUDE_DIR - Module NAME swig (.i) headers
 #  OPENTURNS_NAME_LIBRARY - Module NAME library location
 #  OPENTURNS_NAME_LIBRARIES - Module NAME libraries location
 #  Macro add_module_extra_definitions(MODULE_NAME VERSION)
 #  MUST be called when building a module
 #
 #  ---------------------------------------------------------------------
 #
 #  Copyright (c) 2009 Mathieu Lapointe <lapointe at phimeca dot com>
 #  Copyright (c) 2010 Julien Schueller <schueller at phimeca dot com>
 #
 #  Redistribution and use is allowed according to the terms of the New
 #  BSD license.
 #  For details see the accompanying COPYING-CMAKE-SCRIPTS file.
 #

 include (CheckFunctionExists)
 include (CheckIncludeFileCXX)



 # check dependencies quietly
 if (OpenTURNS_FIND_QUIETLY)
   # except when debugging
   if (NOT OPENTURNS_DEBUG)
     set (_FIND_ARG QUIET)
   endif ()
 endif ()



 # libxml
 if (NOT LIBXML2_FOUND)
   find_package (LibXml2 2.6.27 ${_FIND_ARG})
 endif ()



 # python
 if (NOT PYTHONLIBS_FOUND)
   find_package (PythonLibs 2.5 ${_FIND_ARG})
 endif()



 # include dir
 if (NOT OPENTURNS_INCLUDE_DIR)
   find_path (OPENTURNS_INCLUDE_DIR
     NAMES
       OT.hxx
     PATHS
       ${OPENTURNS_ROOT_DIR}/include
       C:/OpenTURNS/include
     PATH_SUFFIXES
       openturns
     DOC
       "OpenTURNS include directory"
   )
 endif ()



 # set swig include dir
 if (NOT OPENTURNS_SWIG_INCLUDE_DIR)
   set(OPENTURNS_SWIG_INCLUDE_DIR "${OPENTURNS_INCLUDE_DIR}/swig")
 endif ()



 # dependencies includes
 if (NOT OPENTURNS_INCLUDE_DIRS)
   if (OPENTURNS_INCLUDE_DIR)
     set (OPENTURNS_INCLUDE_DIRS ${OPENTURNS_INCLUDE_DIR})
   endif ()
   list (APPEND OPENTURNS_INCLUDE_DIRS ${LIBXML2_INCLUDE_DIR})
   list (APPEND OPENTURNS_INCLUDE_DIRS ${PYTHON_INCLUDE_DIRS}) # cmake >= 2.8.0
   list (APPEND OPENTURNS_INCLUDE_DIRS ${PYTHON_INCLUDE_PATH}) # cmake <= 2.6.4
 endif ()



 # version
 if (NOT OPENTURNS_VERSION)
   if (OPENTURNS_INCLUDE_DIR)
     file (STRINGS "${OPENTURNS_INCLUDE_DIR}/OTconfig.h" _VERSION_STRING
       REGEX ".*PACKAGE_VERSION.*")
     string (REGEX REPLACE ".*_VERSION[ ]+\"([0-9]+\\.[0-9]+\\.[0-9]+).*" "\\1" OPENTURNS_VERSION "${_VERSION_STRING}")
   endif ()
 endif ()



 # check version
 set (_OPENTURNS_VERSION_MATCH TRUE)
 set (_REQUIRED_VERSION "${OpenTURNS_FIND_VERSION_MAJOR}.${OpenTURNS_FIND_VERSION_MINOR}.${OpenTURNS_FIND_VERSION_PATCH}")
 if (OpenTURNS_FIND_VERSION)
   if (OpenTURNS_FIND_VERSION_EXACT)
     if ("${_REQUIRED_VERSION}" VERSION_EQUAL "${OPENTURNS_VERSION}")
     else ()
       set (_OPENTURNS_VERSION_MATCH FALSE)
     endif ()
   else ()
     if ("${_REQUIRED_VERSION}" VERSION_GREATER "${OPENTURNS_VERSION}")
       set (_OPENTURNS_VERSION_MATCH FALSE)
     endif ()
   endif ()
 endif ()



 # check for library directory
 if (NOT OPENTURNS_LIBRARY)
   find_library (OPENTURNS_LIBRARY
     NAMES
       OT
     PATHS
       ${OPENTURNS_ROOT_DIR}/lib
       C:/OpenTURNS/lib
     PATH_SUFFIXES
       openturns
     DOC
       "OpenTURNS library location"
   )
 endif ()



 # find dependent libraries
 if (NOT OPENTURNS_LIBRARIES)
   set (OPENTURNS_LIBRARIES ${OPENTURNS_LIBRARY})
   list (APPEND OPENTURNS_LIBRARIES ${LIBXML2_LIBRARIES})
   list (APPEND OPENTURNS_LIBRARIES ${PYTHON_LIBRARIES})
 endif ()



 # root dir
 if (NOT OPENTURNS_ROOT_DIR)
   # try to guess root dir from include dir
   if (OPENTURNS_INCLUDE_DIR)
     string (REGEX REPLACE "(.*)/include/openturns/?" "\\1" OPENTURNS_ROOT_DIR ${OPENTURNS_INCLUDE_DIR})

   # try to guess root dir from library dir
   elseif (OPENTURNS_LIBRARY)
     string (REGEX REPLACE "(.*)/lib[32|64]?/openturns/.*" "\\1" OPENTURNS_ROOT_DIR ${OPENTURNS_LIBRARY})
   endif ()
 endif ()



 # examples dir
 if (NOT OPENTURNS_EXAMPLES_DIR)
   set (OPENTURNS_EXAMPLES_DIR "${OPENTURNS_ROOT_DIR}/share/openturns/examples")
 endif ()



 # debug
 if (OPENTURNS_DEBUG)
   message (STATUS "OPENTURNS_LIBRARY: ${OPENTURNS_LIBRARY}")
   message (STATUS "OPENTURNS_LIBRARIES: ${OPENTURNS_LIBRARIES}")
   message (STATUS "OPENTURNS_INCLUDE_DIR: ${OPENTURNS_INCLUDE_DIR}")
   message (STATUS "OPENTURNS_INCLUDE_DIRS: ${OPENTURNS_INCLUDE_DIRS}")
   message (STATUS "OPENTURNS_VERSION: ${OPENTURNS_VERSION}")
   message (STATUS "OPENTURNS_SWIG_INCLUDE_DIR: ${OPENTURNS_SWIG_INCLUDE_DIR}")
   message (STATUS "OPENTURNS_ROOT_DIR: ${OPENTURNS_ROOT_DIR}")
   message (STATUS "OPENTURNS_EXAMPLES_DIR: ${OPENTURNS_EXAMPLES_DIR}")
 endif ()



 # handle REQUIRED and QUIET options
 include (FindPackageHandleStandardArgs)
 find_package_handle_standard_args (OpenTURNS DEFAULT_MSG OPENTURNS_LIBRARY
   OPENTURNS_LIBRARIES
   LIBXML2_FOUND
   PYTHONLIBS_FOUND
   OPENTURNS_INCLUDE_DIR OPENTURNS_INCLUDE_DIRS OPENTURNS_SWIG_INCLUDE_DIR
   OPENTURNS_VERSION _OPENTURNS_VERSION_MATCH
   OPENTURNS_ROOT_DIR
   OPENTURNS_EXAMPLES_DIR
 )

 mark_as_advanced (
   OPENTURNS_LIBRARY
   OPENTURNS_INCLUDE_DIR
   OPENTURNS_SWIG_INCLUDE_DIR
   OPENTURNS_INCLUDE_DIRS
   OPENTURNS_VERSION
   OPENTURNS_LIBRARIES
   OPENTURNS_ROOT_DIR
   OPENTURNS_EXAMPLES_DIR
 )






 # wrapper -----------------------------------------------------------------------



 # threads
 if (NOT Threads_FOUND)
   find_package (Threads ${_FIND_ARG})
 endif ()

 # wrapper definitions
 if (NOT OPENTURNS_WRAPPER_DEFINITIONS)
   set(OPENTURNS_WRAPPER_DEFINITIONS)
   if (CMAKE_USE_PTHREADS_INIT)
     list (APPEND OPENTURNS_WRAPPER_DEFINITIONS -DHAVE_PTHREAD_H)
   endif ()
 endif ()



 # find wrapper dir
 if (NOT OPENTURNS_WRAPPER_DIR)
   find_path (OPENTURNS_WRAPPER_DIR
     NAMES
       wrapper.xml
     PATHS
       ${OPENTURNS_ROOT_DIR}
     PATH_SUFFIXES
       share/openturns/wrappers
     DOC
       "OpenTURNS wrapper location"
   )
 endif ()



 if (NOT OPENTURNS_WRAPPER_LIBRARIES)
   set(OPENTURNS_WRAPPER_LIBRARIES ${CMAKE_THREAD_LIBS_INIT})
 endif ()

 # check if wrapper library is usable
 if (NOT OPENTURNS_WRAPPER_FOUND)
   if (Threads_FOUND
         AND CMAKE_USE_PTHREADS_INIT
         AND OPENTURNS_WRAPPER_DEFINITIONS
         AND OPENTURNS_WRAPPER_DIR
         AND OPENTURNS_WRAPPER_LIBRARIES
         AND OPENTURNS_FOUND)
     set (OPENTURNS_WRAPPER_FOUND TRUE)
   else ()
     set (OPENTURNS_WRAPPER_FOUND FALSE)
   endif ()
 endif ()



 mark_as_advanced (
   OPENTURNS_WRAPPER_FOUND
   OPENTURNS_WRAPPER_DIR
   OPENTURNS_WRAPPER_LIBRARIES
   OPENTURNS_WRAPPER_DEFINITIONS
 )





 # module --------------------------------------------------------------



 # find module directory
 if (NOT OPENTURNS_MODULE_DIR)
   set (OPENTURNS_MODULE_DIR "${OPENTURNS_ROOT_DIR}/lib/openturns/module")
 endif ()



 # set module definitions
 if (NOT OPENTURNS_MODULE_DEFINITIONS)
   set (OPENTURNS_MODULE_DEFINITIONS)

   # check for STDC_HEADERS
   if (NOT HAVE_STDLIB_H)
     check_include_file_cxx (stdlib.h HAVE_STDLIB_H)
   endif ()
   if (NOT HAVE_STDARG_H)
     check_include_file_cxx (stdarg.h HAVE_STDARG_H)
   endif ()
   if (NOT HAVE_STRING_H)
     check_include_file_cxx (string.h HAVE_STRING_H)
   endif ()
   if (NOT HAVE_FLOAT_H)
     check_include_file_cxx (float.h HAVE_FLOAT_H)
   endif ()
   check_function_exists (memchr HAVE_MEMCHR)
   if (NOT HAVE_FREE)
     check_function_exists (free HAVE_FREE)
   endif ()
   if (NOT HAVE_CTYPE_H)
     check_include_file_cxx (ctype.h HAVE_CTYPE_H)
   endif ()
   if(HAVE_STDLIB_H AND HAVE_STDARG_H AND HAVE_STRING_H AND HAVE_FLOAT_H AND HAVE_MEMCHR AND HAVE_FREE AND HAVE_CTYPE_H)
     list (APPEND OPENTURNS_MODULE_DEFINITIONS -DSTDC_HEADERS_H=1)
   else ()
     list (APPEND OPENTURNS_MODULE_DEFINITIONS -DSTDC_HEADERS_H=0)
   endif ()

   # this macro checks a header and defines the corresponding macro
   macro (check_include_file_cxx_define_macro header_file)
     # get macro name from header_file
     string (TOUPPER "${header_file}" macro_name)
     string (REGEX REPLACE "[/.]" "_" macro_name ${macro_name})
     set(macro_name HAVE_${macro_name})
     # check for header
     if (NOT ${macro_name})
       check_include_file_cxx (${header_file} ${macro_name})
     endif ()
     # define macro
     if(${macro_name})
       list (APPEND OPENTURNS_MODULE_DEFINITIONS -D${macro_name}=1)
     else()
       list (APPEND OPENTURNS_MODULE_DEFINITIONS -D${macro_name}=0)
     endif ()
   endmacro ()

   # check for some headers
   check_include_file_cxx_define_macro (sys/types.h)
   check_include_file_cxx_define_macro (sys/stat.h)
   check_include_file_cxx_define_macro (stdlib.h)
   check_include_file_cxx_define_macro (string.h)
   check_include_file_cxx_define_macro (memory.h)
   check_include_file_cxx_define_macro (strings.h)
   check_include_file_cxx_define_macro (inttypes.h)
   check_include_file_cxx_define_macro (stdint.h)
   check_include_file_cxx_define_macro (unistd.h)
   check_include_file_cxx_define_macro (dlfcn.h)
   check_include_file_cxx_define_macro (stdbool.h)
   check_include_file_cxx_define_macro (regex.h)
 endif ()



 mark_as_advanced (
   OPENTURNS_MODULE_DIR
   OPENTURNS_MODULE_DEFINITIONS
 )



 # add module defs
 macro (add_module_extra_definitions module_name)
   add_definitions (-DPACKAGE_NAME="OpenTURNS module ${module_name}")
   add_definitions (-DPACKAGE_TARNAME="${module_name}")
   add_definitions (-DPACKAGE_VERSION="${OPENTURNS_VERSION}")
   add_definitions (-DPACKAGE_STRING="OpenTURNS module ${module_name} ${OPENTURNS_VERSION}")
   add_definitions (-DPACKAGE_BUGREPORT="")
 endmacro ()





 # modules ----------------------------------------------------------------------

 # find modules
 if (OpenTURNS_FIND_COMPONENTS)
   foreach (module_name ${OpenTURNS_FIND_COMPONENTS})
     string(TOLOWER ${module_name} module_lowercase_name)
     string(TOUPPER ${module_name} module_uppercase_name)

     set (OPENTURNS_${module_uppercase_name}_FOUND FALSE)

     # module library
     if (NOT OPENTURNS_${module_uppercase_name}_LIBRARY)
       find_library (OPENTURNS_${module_uppercase_name}_LIBRARY
         NAMES
           ${module_name}
         PATHS
           ${OPENTURNS_MODULE_DIR}/lib
         PATH_SUFFIXES
           ${module_lowercase_name}
       )
     endif ()

     # module libraries
     if (NOT OPENTURNS_${module_uppercase_name}_LIBRARIES)
       set (OPENTURNS_${module_uppercase_name}_LIBRARIES ${OPENTURNS_${module_uppercase_name}_LIBRARY})
       list (APPEND OPENTURNS_${module_uppercase_name}_LIBRARIES ${OPENTURNS_LIBRARIES})
     endif ()

     # module include dir
     if (NOT OPENTURNS_${module_uppercase_name}_INCLUDE_DIR)
       set (OPENTURNS_${module_uppercase_name}_INCLUDE_DIR "${OPENTURNS_MODULE_DIR}/include/${module_lowercase_name}")
     endif ()

     # module include dirs
     if (NOT OPENTURNS_${module_uppercase_name}_INCLUDE_DIRS)
       set (OPENTURNS_${module_uppercase_name}_INCLUDE_DIRS ${OPENTURNS_${module_uppercase_name}_INCLUDE_DIR})
       list (APPEND OPENTURNS_${module_uppercase_name}_INCLUDE_DIRS ${OPENTURNS_INCLUDE_DIRS})
     endif ()

     # module swig include dir
     if (NOT OPENTURNS_${module_uppercase_name}_SWIG_INCLUDE_DIR)
       set (OPENTURNS_${module_uppercase_name}_SWIG_INCLUDE_DIR "${OPENTURNS_MODULE_DIR}/share/${module_lowercase_name}/swig")
     endif ()

     # test if the module is found
     if (NOT OPENTURNS_${module_uppercase_name}_FOUND)
       if (OPENTURNS_${module_uppercase_name}_LIBRARY
             AND OPENTURNS_${module_uppercase_name}_LIBRARIES
             AND OPENTURNS_${module_uppercase_name}_INCLUDE_DIR
             AND OPENTURNS_${module_uppercase_name}_INCLUDE_DIRS
             AND OPENTURNS_${module_uppercase_name}_SWIG_INCLUDE_DIR
             AND OPENTURNS_FOUND)
         set (OPENTURNS_${module_uppercase_name}_FOUND TRUE)
       else ()
         set (OPENTURNS_${module_uppercase_name}_FOUND FALSE)
       endif ()
     endif ()

     # handle REQUIRED and QUIET options
     if (OPENTURNS_${module_uppercase_name}_FOUND)
       if (NOT OpenTURNS_FIND_QUIETLY)
         message (STATUS "Found OpenTURNS module ${module_name}: ${OPENTURNS_${module_uppercase_name}_LIBRARY}")
       endif ()
     else ()
       if (OpenTURNS_FIND_REQUIRED)
         message(SEND_ERROR "Unable to find the requested OpenTURNS module : ${module_name}")
       endif ()
       if (NOT OpenTURNS_FIND_QUIETLY)
         message (STATUS "Could not find OpenTURNS module ${module_name}")
       endif ()
     endif ()

     mark_as_advanced (
       OPENTURNS_${module_uppercase_name}_FOUND
       OPENTURNS_${module_uppercase_name}_LIBRARY
       OPENTURNS_${module_uppercase_name}_LIBRARIES
       OPENTURNS_${module_uppercase_name}_INCLUDE_DIR
       OPENTURNS_${module_uppercase_name}_INCLUDE_DIRS
       OPENTURNS_${module_uppercase_name}_SWIG_INCLUDE_DIR
     )

   endforeach ()
 endif ()





 # debug ------------------------------------------------------------------------------------------

 if (OPENTURNS_DEBUG)
   message (STATUS "OPENTURNS_FOUND: ${OPENTURNS_FOUND}")

   message (STATUS "OPENTURNS_WRAPPER_FOUND: ${OPENTURNS_WRAPPER_FOUND}")
   message (STATUS "OPENTURNS_WRAPPER_DIR: ${OPENTURNS_WRAPPER_DIR}")
   message (STATUS "OPENTURNS_WRAPPER_DEFINITIONS: ${OPENTURNS_WRAPPER_DEFINITIONS}")
   message (STATUS "OPENTURNS_WRAPPER_LIBRARIES: ${OPENTURNS_WRAPPER_LIBRARIES}")

   message (STATUS "OPENTURNS_MODULE_DIR: ${OPENTURNS_MODULE_DIR}")
   message (STATUS "OPENTURNS_MODULE_DEFINITIONS: ${OPENTURNS_MODULE_DEFINITIONS}")

   foreach (module_name ${OpenTURNS_FIND_COMPONENTS})
     message (STATUS "OPENTURNS_${module_uppercase_name}_FOUND: ${OPENTURNS_${module_uppercase_name}_FOUND}")
     message (STATUS "OPENTURNS_${module_uppercase_name}_LIBRARY: ${OPENTURNS_${module_uppercase_name}_LIBRARY}")
     message (STATUS "OPENTURNS_${module_uppercase_name}_LIBRARIES: ${OPENTURNS_${module_uppercase_name}_LIBRARIES}")
     message (STATUS "OPENTURNS_${module_uppercase_name}_INCLUDE_DIR: ${OPENTURNS_${module_uppercase_name}_INCLUDE_DIR}")
     message (STATUS "OPENTURNS_${module_uppercase_name}_INCLUDE_DIRS: ${OPENTURNS_${module_uppercase_name}_INCLUDE_DIRS}")
     message (STATUS "OPENTURNS_${module_uppercase_name}_SWIG_INCLUDE_DIR: ${OPENTURNS_${module_uppercase_name}_SWIG_INCLUDE_DIR}")
   endforeach ()
 endif ()

Back


CMake: [Welcome | Site Map]
Retrieved from "https://public.kitware.com/Wiki/index.php?title=CMakeUserFindOpenTURNS&oldid=26677"