yap-6.3/CMakeLists.txt

# value of 3.4.0 or lower.
cmake_minimum_required(VERSION 3.4)

# Sets the version of CMake required to build the native
# library. You should either keep the default value or  pass a
# value of 3.4.0 or lower.
include(CMakeToolsHelpers OPTIONAL)

include(FeatureSummary)
include(GNUInstallDirs)

project(YAP)

set(YAP_APP_DIR "${CMAKE_SOURCE_DIR}/../..")
cmake_policy(VERSION 3.4)

set( CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}" "${CMAKE_SOURCE_DIR}/cmake")

    set(ANACONDA $ENV{CONDA_BUILD} CACHE BOOL "Anaconda Environment")
    message(STATUS "ANACONDA found:   ${ANACONDA}")

include(CheckIncludeFiles)
include(CheckLibraryExists)
include(CheckSymbolExists)
include(CheckTypeSize)
include(CMakeDependentOption)
include(MacroOptionalAddSubdirectory)
include(MacroOptionalFindPackage)
include(FeatureSummary)
include(FindPackageHandleStandardArgs)

# Optional Components
#
include(CheckIncludeFileCXX)
include(CheckFunctionExists)
include(CheckFunctionExists)
include(CheckPrototypeExists)
include(CheckVariableExists)
include(CheckCXXSourceCompiles)
include(TestBigEndian)
include(GetGitRevisionDescription)

# Creates and names a library, sets it as either STATIC
# or SHARED, and provides the relative paths to its source code.z
# You can define  libraries, and CMake builds it for you.
# Gradle automatically packages shared libraries with your APK.

#cross-compilation support
# Search packages for host system instead of packages for target system
# in case of cross compilation define these macro by toolchain file
if (NOT COMMAND find_host_package)
    macro(find_host_package)
        find_package(${ARGN})
    endmacro()
endif ()
if (NOT COMMAND find_host_program)
    macro(find_host_program)
        find_program(${ARGN})
    endmacro()
endif ()

if (POLICY CMP0003)
    cmake_policy(SET CMP0003 NEW)
endif ()
if (POLICY CMP0068)
    cmake_policy(SET CMP0068 NEW)
endif ()

option(BUILD_SHARED_LIBS "Build shared library" ON)

set(CMAKE_POSITION_INDEPENDENT_CODE TRUE)
set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS TRUE)

#begining stuff for top CMakeLists

include(MacroLogFeature)

if (POLICY CMP0042)
    cmake_policy(SET CMP0042 NEW)
endif ()

function(add_to_group list output)
    set(tmp ${${output}})
    foreach (path ${${list}})
        get_source_file_property(path ${path} LOCATION)
        list(APPEND tmp ${path})
    endforeach ()
    set(${output} ${tmp} CACHE INTERNAL "prolog library files")
endfunction(add_to_group list output)

function(add_to_libgroup el list)
    # add_custom_command(  TARGET ${el} POST_BUILD
    #   COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${el}>  ${CMAKE_BINARY_DIR}/packages/python/swig/yap4py
    #   DEPENDS   ${el} )
    list(APPEND ${list} ${${el}})
    set(${list} ${${list}} CACHE INTERNAL "prolog dll files")
endfunction(add_to_libgroup el list)


function(add_to_corelibgroup el list)
    # add_custom_command(  TARGET ${el} POST_BUILD
    #   COMMAND ${CMAKE_COMMAND} -E copy $<TARGET_FILE:${el}> $<TARGET_SONAME_FILE:${el}>  $<TARGET_LINKER_FILE:${el}>  ${CMAKE_BINARY_DIR}/packages/python/swig/yap4py
    #   DEPENDS   ${el} )
    list(APPEND ${list} ${${el}})
    set(${list} ${${list}} CACHE INTERNAL "prolog dll files")
endfunction(add_to_corelibgroup el list)


if (ANDROID_OLD)
    macro(MY_add_custom_target)
    endmacro()
else ()
    macro(MY_add_custom_target)
        add_custom_target(${ARGN})
    endmacro()
endif ()

if (WIN32)
    macro(add_component arg1)
        add_library(${arg1} OBJECT ${ARGN})
    endmacro()
else ()
    macro(add_component arg1)
        add_library(${arg1} OBJECT ${ARGN})
    endmacro()
endif ()
macro(add_lib arg1)
    add_library(${arg1} SHARED ${ARGN})
    add_to_libgroup(${arg1} YAP_DLLS)
endmacro()
macro(add_corelib arg1)
    add_library(${arg1} SHARED ${ARGN})
    add_to_corelibgroup(${arg1} YAP_DLLS)
endmacro()

if (ANDROID_OLD)
    macro(MY_add_dependencies)
    endmacro()
else ()
    macro(MY_add_dependencies)
        add_dependencies(${ARGN})
    endmacro()
endif ()

if (ANDROID_OLD)
    macro(MY_add_library)
    endmacro()
else ()
    macro(MY_add_library)
        add_library(${ARGN})
    endmacro()
endif ()

if (ANDROID)
    macro(MY_add_subdirectory)
    endmacro()
else ()
    macro(MY_add_subdirectory)
        add_subdirectory(${ARGN})
    endmacro()
endif ()

if (ANDROID_OLD)
    macro(MY_include)
    endmacro()
else ()
    macro(MY_include)
        include(${ARGN})
    endmacro()
endif ()

if (ANDROID)
    macro(MY_install)
    endmacro()
else ()
    macro(MY_install)
        install(${ARGN})
    endmacro()
endif ()

if (ANDROID_OLD)
    macro(MY_set_target_properties)
    endmacro()
else ()
    macro(MY_set_target_properties)
        set_target_properties(${ARGN})
    endmacro()
endif ()

if (ANDROID_OLD)
    macro(MY_target_link_libraries)
    endmacro()
else ()
    macro(MY_target_link_libraries)
        target_link_libraries(${ARGN})
    endmacro()
endif ()


# where we have most scripts
# set path to additional CMake modules

set(CMAKE_EXPORT_COMPILE_COMMANDS ON)

include(disallow)

disallow_intree_builds()

# set(CMAKE_BUILD_TYPE  Debug)

if (ANACONDA)
    set(CMAKE_LIBRARY_ARCHITECTURE $ENV{PREFIX})
    set(CMAKE_PREFIX_PATH $ENV{PREFIX} $ENV{SYS_PREFIX})
        set( PATH $ENV{PREFIX}/bin $ENV{SYS_PREFIX}/bin ${PATH} )
    set( PYTHON_EXECUTABLE "$ENV{PYTHON}")
    set( R_COMMAND "$ENV{R}")
#      set(CMAKE_INCLUDE_PATH  $ENV{SYS_PREFIX}/include ${CMAKE_INCLUDE_PATH} )
#set(CMAKE_LIBRARY_PATH $ENV{SYS_PREFIX}/lib $ENV{SYS_PREFIX}/lib ${CMAKE_LIBRARY_PATH})
#        set(ENV{PATH} PATH $ENV{PREFIX}/bin $ENV{SYS_PREFIX}/bin $ENV{PATH})
#        set(PATH $ENV{PATH} ${PATH})
    #set( CMAKE_INSTALL_FULL_PREFIX $ENV{PREFIX} )
        set( PYTHON_LIBRARY $ENV{PREFIX}/lib/libpython$ENV{PY_VER}m$ENV{SHLIB_EXT})
    set( PYTHON_INCLUDE_DIR $ENV{PREFIX}/include/python$ENV{PY_VER}m)
set(YAP_IS_MOVABLE 1)
endif()

ADD_CUSTOM_TARGET(run_install COMMAND ${CMAKE_MAKE_PROGRAM} install)


if (APPLE)
    set(MACOSX_RPATH ON)
    if (NOT ANACONDA)
        set(PATH $ENV{PATH})
        list(FIND ${PATH} pos /usr/local)
        if (pos EQUAL -1)
            set(pos 0)
        endif ()
        list(INSERT CMAKE_PREFIX_PATH pos
                /usr/local/opt/gmp
                /usr/local/opt/libxml2
                /usr/local/opt/openmpi
                /usr/local/opt/openssl
                /usr/local/opt/postgresql
                /usr/local/opt/python3
                /usr/local/opt/readline
                /usr/local/opt/swig
                )
    endif ()
endif ()

set(YAP_ROOTDIR ${CMAKE_INSTALL_PREFIX})
# erootdir -> rootdir
# libdir defined above
set(YAP_DATADIR  ${CMAKE_INSTALL_FULL_DATADIR})
set(YAP_INCLUDEDIR  ${CMAKE_INSTALL_FULL_INCLUDEDIR}/Yap)
set(YAP_LIBDIR  ${CMAKE_INSTALL_FULL_LIBDIR})
set(YAP_DLLDIR  ${CMAKE_INSTALL_FULL_LIBDIR}/Yap)
set(YAP_PLDIR  ${CMAKE_INSTALL_FULL_DATADIR}/Yap)

set(YAP_INSTALL_DLLDIR ${CMAKE_INSTALL_LIBDIR}/Yap)
set(YAP_INSTALL_PLDIR ${CMAKE_INSTALL_DATADIR}/Yap)

set(libpl ${YAP_INSTALL_PLDIR})

#
#
# include( Sources  )
#
# include( Model   )

include(cudd )
include(java )

set(pl_library "" CACHE INTERNAL "prolog library files")
set(pl_os_library "" CACHE INTERNAL "prolog os files")
set(pl_boot_library "" CACHE INTERNAL "prolog boot files")


find_package(GMP)
# GMP_FOUND         - true if GMP/MPIR was found
# GMP_INCLUDE_DIRS  - include search path
# GMP_LIBRARIES      - libraries to link with
# GMP_LIBRARY_    #add_executable(test ${SOURCES})

list(APPEND YAP_SYSTEM_OPTIONS big_numbers)

include(FindReadline)

List(APPEND YAP_SYSTEM_OPTIONS readline)
# include subdirectories configuration
## after we have all functionality in
#
# ADD_SUBDIRECTORY(console/terminal)


#MPI STUFF
# library/mpi/mpi.c library/mpi/mpe.c
# library/lammpi/yap_mpi.c library/lammpi/hash.c library/lammpi/prologterms2c.c
# )

#WIN STUFF
# SET(PLCONS_SOURCES
#   console/LGPL/pl-nt.c
#   console/LGPL/pl-ntcon.c
#   console/LGPL/pl-ntconsole.c
#   console/LGPL/pl-ntmain.c
# )
set(YAP_FOUND ON)

set(YAP_MAJOR_VERSION 6)
set(YAP_MINOR_VERSION 3)
set(YAP_PATCH_VERSION 5)

set(YAP_FULL_VERSION
        ${YAP_MAJOR_VERSION}.${YAP_MINOR_VERSION}.${YAP_PATCH_VERSION})
set(YAP_FVERSION
        ${YAP_MAJOR_VERSION}.${YAP_MINOR_VERSION}.${YAP_PATCH_VERSION})
set(YAP_NUMERIC_VERSION
        ${YAP_MAJOR_VERSION}*10000+${YAP_MINOR_VERSION}*100+${YAP_PATCH_VERSION})
set(MYDDAS_VERSION MYDDAS-0.9.1)

site_name(YAP_SITE)


if (WIN32)
    set(YAP_ARCH $ENV{PROCESSOR_ARCHITECTURE})
    set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "MS_WIN64=1")
    set(YAP_SYSTEM_OPTIONS "windows " ${YAP_SYSTEM_OPTIONS})
endif ()
if (UNIX)
    find_program(UNAME uname)
    execute_process(
            COMMAND ${UNAME} -m
            OUTPUT_VARIABLE YAP_ARCH OUTPUT_STRIP_TRAILING_WHITESPACE)
    set(YAP_SYSTEM_OPTIONS "unix " ${YAP_SYSTEM_OPTIONS})
endif ()


#
set(MIN_STACKSPACE 1024*SIZEOF_INT_P)
set(MIN_HEAPSPACE 32*1024*SIZEOF_INT_P)
set(MIN_TRAILSPACE 512*SIZEOF_INT_P)
set(DEF_STACKSPACE 0)
set(DEF_HEAPSPACE 0)
set(DEF_TRAILSPACE 0)

# option (RATIONAL_TREES "support infinite rational trees" ON)
# dd_definitions (-D)

## don't touch these opts
set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS DEPTH_LIMIT=1;COROUTINING=1;RATIONAL_TREES=1)

# inform we are compiling YAP
set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS "_YAP_NOT_INSTALLED_=1;HAVE_CONFIG_H=1;_GNU_SOURCE")

# Compilation model
#  target_compile_definitions(libYap PUBLIC  _XOPEN_SOURCE=700 )

#add_definitions( -Wall  -Wstrict-prototypes -Wmissing-prototypes)

# Model Specific
set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS $<$<CONFIG:Debug>:DEBUG=1>)

#ensure cells are properly aligned in code
set(ALIGN_LONGS 1)

#ensure best access to slots in environments
set(MSHIFTOFFS 1)

set(C_COMPILER CMAKE_C_COMPILER_ID)

if (${C_COMPILER} MATCHES "GNU")
    set(HAVE_GCC 1)
endif ()

# compatible compilers
if (${C_COMPILER} MATCHES "Clang")
    set(HAVE_GCC 1)
endif ()

if (${C_COMPILER} MATCHES "Intel")
    set(HAVE_GCC 1)
endif ()

# Model Specific
if (HAVE_GCC)
    set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS -Wall)
    if (${C_COMPILER} MATCHES "GNU")
        set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS $<$<CONFIG:Release>:-O3;-fomit-frame-poinkter;-fstrict-aliasing;-freorder-blocks;-fsched-interblock>)
    else ()
        set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS $<$<CONFIG:Release>:-O3;-fstrict-aliasing;-freorder-blocks;-fsched-interblock>)
    endif ()
    set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS -fexceptions)
endif ()

# set_property( DIRECTORY APPEND_STRING PROPERTY -fsanitize=memory;-fsanitize-memory-track-origins=2)
if (HAVE_GCC)
    # replace instructions codes by the address of their code
    option(WITH_THREADED_CODE "threaded code" ON)
    if (WITH_THREADED_CODE)
        set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS THREADED_CODE=1)
    endif (WITH_THREADED_CODE)
endif (HAVE_GCC)

#
#option (YAP_SWI_IO ON)

OPTION(WITH_CALL_TRACER
        "support for procedure-call tracing" ON)
#TODO:
if (WITH_CALL_TRACER)
    list(APPEND YAP_SYSTEM_OPTIONS "call_tracer " ${YAP_SYSTEM_OPTIONS})
    set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS $<$<CONFIG:Debug>:LOW_LEVEL_TRACER=1>)
endif (WITH_CALL_TRACER)

set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS UTF8PROC=1)

include_directories(utf8proc packages/myddas packages/myddas/sqlite3/src)


if (ANDROID)
    include_directories(
            packages/myddas/sqlite3/src/Android/jni/sqlite
            packages/myddas/sqlite3/src/Android/jni/sqlite/nativehelper
    )
endif (ANDROID)

set_property(SOURCE ${LIBYAP_SOURCES} APPEND PROPERTY COMPILE_DEFINITIONS YAP_KERNEL=1)

add_definitions(-DUSE_MYDDAS=1 -DMYDDAS_SQLITE3=1)

if (MYSQL_FOUND)
    add_definitions(= -DMYDDAS_MYSQL=1)
endif ()

if (ODBC_FOUND)
    add_definitions(= -DMYDDAS_ODBC=1)
endif ()

if (MYSQL_POSTGRES)
    add_definitions(= -DMYDDAS_POSTGRES=1)
endif ()


OPTION(WITH_SWIG " Enable SWIG interfaces to foreign languages" ON)

IF (WITH_SWIG)
    find_host_package(SWIG)
    # macro_log_feature (SWIG_FOUND "Swig"
    #         "Use SWIG Interface Generator "
    #         "http://www.swig.org" ON)
ENDIF (WITH_SWIG)


option(WITH_PYTHON
        "Allow Python->YAP  and YAP->Python" ON)

IF (WITH_PYTHON)
    include(python )
ENDIF (WITH_PYTHON)


List(APPEND YLIBS $<TARGET_OBJECTS:libOPTYap>)
List(APPEND YLIBS $<TARGET_OBJECTS:libYAPOs>)
List(APPEND YLIBS $<TARGET_OBJECTS:utf8proc>)
List(APPEND YLIBS $<TARGET_OBJECTS:myddas>)
List(APPEND YLIBS $<TARGET_OBJECTS:libswi>)
if (WIN32)
    List(APPEND YLIBS $<TARGET_OBJECTS:Yapsqlite3>)
    List(APPEND YLIBS $<TARGET_OBJECTS:YAP++>)
    if (WITH_PYTHON)
        List(APPEND YLIBS $<TARGET_OBJECTS:Py4YAP>)
    endif ()
endif ()

include(Sources)


add_corelib( # Sets the name of the library.
        libYap

        # Sets the library as a shared library.
        SHARED

        ${ENGINE_SOURCES}
        ${C_INTERFACE_SOURCES}
        //${STATIC_SOURCES}
        # cmake object libraries
        ${YLIBS}
        )

if (WIN32)
   target_link_libraries(libYap ${WINDLLS})
     if (PYTHON_INCLUDE_DIRS AND PYTHON_LIBRARIES)
        target_link_libraries(libYap ${PYTHON_LIBRARIES})
    endif ()
endif (WIN32)

target_link_libraries(libYap m)

if (GMP_FOUND)
    #config.h needs this (TODO: change in code latter)
    include_directories(${GMP_INCLUDE_DIRS})
    target_link_libraries(libYap ${GMP_LIBRARIES})
endif (GMP_FOUND)

if (READLINE_FOUND)
    include_directories(${READLINE_INCLUDE_DIR})
    target_link_libraries(libYap ${READLINE_LIBRARIES})
    # required for configure
    list(APPEND CMAKE_REQUIRED_LIBRARIES ${READLINE_LIBRARIES})
    list(APPEND CMAKE_REQUIRED_INCLUDES ${READLINE_INCLUDE_DIR})
endif ()


set(YAP_STARTUP startup.yss)
set(YAP_BOOTFILE boot.yap                                                                                                                                                                                                                                                                                                                           )
## define system

# Optional libraries that affect compilation
#


set(CMAKE_TOP_BINARY_DIR ${CMAKE_BINARY_DIR})
set(YAP_PL_SRCDIR ${CMAKE_SOURCE_DIR}/pl)

set(YAP_YAPLIB libYap${CMAKE_SHARED_LIBRARY_SUFFIX})

string(TIMESTAMP YAP_TIMESTAMP)

string(SUBSTRING ${CMAKE_SHARED_LIBRARY_SUFFIX} 1 -1 SO_EXT)

set_property(DIRECTORY PROPERTY CXX_STANDARD 11)

# rpath stuff, hopefully it works
# use, i.e. don't skip the full RPATH for the build tree
#SET(CMAKE_SKIP_BUILD_RPATH  FALSE)


# when building, don't use the install RPATH already
# (but later on when installing)
#SET(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE)

# SET(CMAKE_INSTALL_FULL_RPATH ${CMAKE_TOP_BINARY_DIR})

# add the automatically determined parts of the RPATH
# which point to directories outside the build tree to the install RPATH
# SET(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE)


# the RPATH to be used when installing, but only if it's not a system directory
LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${libdir}" isSystemDir)
 IF("${isSystemDir}" STREQUAL "-1")
    SET(CMAKE_INSTALL_RPATH ${libdir})
 ENDIF("${isSystemDir}" STREQUAL "-1")

include_directories(H
        H/generated
        include os OPTYap utf8proc JIT/HPP)
include_directories(BEFORE ${CMAKE_BINARY_DIR} ${CMAKE_TOP_BINARY_DIR})

if (ANDROID)
    include_directories(CXX ${CMAKE_SOURCE_DIR}/../generated/src/jni)
endif ()
include(Threads)
#
# include OS and I/o stuff
#
# convenience libraries
# OPTYap exports important flags
#
list(APPEND YAP_SYSTEM_OPTIONS "thread support")

set_target_properties(libYap
        PROPERTIES OUTPUT_NAME Yap
        )
MY_set_target_properties(libYap
        PROPERTIES VERSION ${YAP_FULL_VERSION}
        SOVERSION ${YAP_MAJOR_VERSION}.${YAP_MINOR_VERSION}
        )


#utf-8 is not an option
# we use the nice UTF-8 package
#available at the Julia project

ADD_SUBDIRECTORY(OPTYap)
ADD_SUBDIRECTORY(os)
ADD_SUBDIRECTORY(packages/myddas)
ADD_SUBDIRECTORY(utf8proc)
ADD_SUBDIRECTORY(library/dialect/swi/fli)
ADD_SUBDIRECTORY(CXX)


add_subDIRECTORY(H)

#bootstrap and saved state
add_subDIRECTORY(pl)

ADD_SUBDIRECTORY(library)

ADD_SUBDIRECTORY(swi/library "swiLibrary")

set_target_properties(libYap
        PROPERTIES OUTPUT_NAME Yap
        )

# file(MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/packages/python/swig/yap4py)

if (PYTHONLIBS_FOUND AND SWIG_FOUND)
    add_subdirectory(packages/python/swig)

    include(FindPythonModule)

    find_python_module(jupyter)

    if (PY_JUPYTER)
        add_subdirectory(packages/python/yap_kernel)
    ENDIF ()
endif ()


IF ( ANDROID)
   add_subDIRECTORY(packages/swig )
    target_link_libraries(libYap android log)
ENDIF ()


message(STATUS "Building YAP packages version ${YAP_VERSION}")


if (NOT WIN32)
    set(BUILD_SHARED_LIBS ON)
endif ()


option(WITH_JIT
        "just in Time Clause Compilation" OFF)
if (WITH_JIT)
    add_subDIRECTORY(JIT)
endif (WITH_JIT)

add_subDIRECTORY(packages/raptor)

add_subDIRECTORY(packages/xml)


OPTION(WITH_CLPBN " Enable the CLPBN and PFL probabilistic languages" ON)

OPTION(WITH_CPLINT " Enable the cplint probabilistic language" ON)

OPTION(WITH_HORUS " Enable the CLPBN and PFL probabilistic languages" ON)

OPTION(WITH_DOCS " Enable documentation, requires doxygen-yap" ON)

IF (WITH_CLPBN)
    add_subDIRECTORY(packages/CLPBN)
ENDIF (WITH_CLPBN)

IF (WITH_CPLINT)
    add_subDIRECTORY(packages/cplint)
ENDIF (WITH_CPLINT)

# please install doxygen for prolog first
# git clone http://www.github.com/vscosta/doxygen-yap
# cd doxygen-yap
# mkdir -p build
# cd build
# make; sudo make install
option(WITH_DOCS
        "generate YAP docs" OFF)

IF (WITH_DOCS)
    add_subDIRECTORY(docs)
ENDIF (WITH_DOCS)

# add_subDIRECTORY (packages/cuda)

option(WITH_GECODE
        "interface gecode constraint solver" ON)
if (WITH_GECODE)
    add_subDIRECTORY(packages/gecode)
endif ()

add_subDIRECTORY(packages/real)


add_subDIRECTORY(packages/jpl)

add_subDIRECTORY(packages/bdd)

add_subDIRECTORY(packages/ProbLog)

add_subDIRECTORY(packages/swi-minisat2)

add_subDIRECTORY(packages/clpqr)


#todo: use cmake target builds
# option (USE_MAXPERFORMANCE
#   "try using the best flags for specific architecture" OFF)

# option (USE_MAXMEMORY
#   "try using the best flags for using the memory to the most" ON)
#TODO: check MAXMEMORY

#TODO: use cmake target builds
# option (USE_DEBUGYAP
#   "enable C-debugging for YAP" OFF)

#TODO: use cmake arch/compiler
# option (USE_CYGWIN
#   "use cygwin library in WIN32" OFF)

option(WITH_PRISM
        "use PRISM system in YAP" ON)
#TODO:


option(WITH_YAP_DLL
        "compile YAP as a DLL" ON)
#TODO:

option(WITH_YAP_STATIC
        "compile YAP statically" OFF)
#TODO:

option(WITH_YAP_CONDOR
        "allow YAP to be used from condor" OFF)

if (WITH_YAP_CONDOR)
    # use default allocator
    set(YAP_STATIC ON)
    set(YAP_DLL OFF)
endif ()

#TODO: detect arch before allow this option
# OPTION(WIN64
#   "compile YAP for win64" OFF)

# option (APRIL
#   "compile Yap to support April ILP system" OFF)
# option (DLCOMPAT
#   "use dlcompat library for dynamic loading on Mac OS X" OFF)

# SHARED PACKAGES with SWI

# swi packages have both Makefile.in which we will use and
# Makefile.mak, we will use the later to identify this packages
# while we keep both autotools amd cmake working side by side
# Search for available packages which all have a Makefile.mak
#file (GLOB PACKAGES packages/*/Makefile.mak)

# needed by this packages


if (WIN32)

    if (MSVC)
        set(MSVC_RUNTIME "dynamic")
    ENDIF (MSVC)

    target_link_libraries(libYap wsock32 ws2_32 Shlwapi)

endif (WIN32)

add_executable(yap-bin ${CONSOLE_SOURCES})

set_target_properties(yap-bin PROPERTIES OUTPUT_NAME yap)


target_link_libraries(yap-bin libYap)

install(TARGETS libYap yap-bin
        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
        )


CMAKE_DEPENDENT_OPTION(WITH_SYSTEM_MMAP "Use MMAP for shared memory allocation" ON
        "NOT WITH_YAPOR_THOR" OFF)

CMAKE_DEPENDENT_OPTION(WITH_SYSTEM_SHM "Use SHM for shared memory allocation" ON
        "NOT WITH_YAPOR_THOR; NOT WITH_SYSTEM_MMAP" OFF)

if (NOT ANDROID)

add_subDIRECTORY(library/lammpi)

if (MPI_C_FOUND)

    CMAKE_DEPENDENT_OPTION(WITH_MPI ON "Interface to OpenMPI/MPICH"
            "MPI_C_FOUND" OFF)
    macro_optional_add_subDIRECTORY(library/mpi)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${MPI_C_COMPILE_FLAGS} ")
    include_directories(${MPI_C_INCLUDE_PATH})
    target_link_libraries(yap-bin ${MPI_C_LIBRARIES})
    if (MPI_C_COMPILE_FLAGS)
        set_target_properties(yap-bin PROPERTIES
                COMPILE_FLAGS "${MPI_C_COMPILE_FLAGS}")
    endif (MPI_C_COMPILE_FLAGS)

    if (MPI_C_LINK_FLAGS)
        set_target_properties(yap-bin PROPERTIES
                LINK_FLAGS "${MPI_C_LINK_FLAGS}")
    endif ()
endif (MPI_C_FOUND)

endif(NOT ANDROID)

##   add_subDIRECTORY(utils)

#

install(FILES ${INCLUDE_HEADERS} ${CONFIGURATION_HEADERS} DESTINATION ${YAP_INCLUDEDIR} )



macro_display_feature_log()
if (POLICY CMP0058)
    cmake_policy(SET CMP0058 NEW)
endif (POLICY CMP0058)

include(Config )


feature_summary(WHAT ENABLED_FEATURES DISABLED_FEATURES
        INCLUDE_QUIET_PACKAGES
        )