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.fg
include(CMakeToolsHelpers OPTIONAL)

include(FeatureSummary)
include(GNUInstallDirs)

project(YAP)

set(YAP_APP_DIR "${CMAKE_SOURCE_DIR}/../yaplib")
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()
if (POLICY CMP0075)
cmake_policy(SET CMP0075 NEW)
endif ()

## options: compilation flags
option(BUILD_SHARED_LIBS "Build shared library" ON)
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)
OPTION(WITH_CALL_TRACER  "support for procedure-call tracing" ${DEBUG})
option(WITH_YAP_DLL "compile YAP as a DLL" ON)
option(WITH_YAP_STATIC  "compile YAP statically" OFF)
option(WITH_YAP_CONDOR   "allow YAP to be used from condor" OFF)
option(WITH_YAP_DLL  "compile YAP as a DLL" ON)
if (WITH_YAP_CONDOR)
  set(WITH_YAP_STATIC ON)
  set(WITH_YAP_DLL OFF)
endif ()

## options: libraries
option(WITH_THREADED_CODE "threaded code" ON)
if (NOT ANDROID)
option(WITH_MPI "Interface to OpenMPI/MPICH" ON)
  endif()
option(WITH_JIT  "just in Time Clause Compilation" OFF)

if (APPLE)
  set(MACOSX_RPATH ON)

  option(WITH_BREW "brew" ON)
  if (WITH_BREW)
    EXECUTE_PROCESS(COMMAND brew --prefix RESULT_VARIABLE DETECT_BREW OUTPUT_VARIABLE BREW_PREFIX ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)

    IF (${DETECT_BREW} EQUAL 0)

      # "/opt/local" is where MacPorts lives, add `/lib` suffix and link
      LINK_DIRECTORIES( ${BREW_PREFIX}/lib)

      list(INSERT CMAKE_PREFIX_PATH pos
        ${BREW_PREFIX}/opt/gmp
        ${BREW_PREFIX}/opt/libxml2
        ${BREW_PREFIX}/opt/openmpi
        ${BREW_PREFIX}/opt/openssl
        ${BREW_PREFIX}/opt/postgresql
        ${BREW_PREFIX}/opt/python3
        ${BREW_PREFIX}/opt/readline
        ${BREW_PREFIX}/opt/swig
        )
    else()
      option(WITH_MACPORTS "mac-ports" ON)
      if (WITH_MACPORTS)
	# Add MacPorts
	# Detect if the "port" command is valid on this system; if so, return full path
	EXECUTE_PROCESS(COMMAND which port RESULT_VARIABLE DETECT_MACPORTS OUTPUT_VARIABLE MACPORTS_PREFIX ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)

	IF (${DETECT_MACPORTS} EQUAL 0)
 	  # "/opt/local/bin/port" doesn't have libs, so we get the parent directory
 	  GET_FILENAME_COMPONENT(MACPORTS_PREFIX ${MACPORTS_PREFIX} DIRECTORY)

 	  # "/opt/local/bin" doesn't have libs, so we get the parent directory
 	  GET_FILENAME_COMPONENT(MACPORTS_PREFIX ${MACPORTS_PssREFIX} DIRECTORY)

 	  # "/opt/local" is where MacPorts lives, add `/lib` suffix and link
 	  LINK_DIRECTORIES(${LINK DIRECTORIES} ${MACPORTS_PREFIX}/lib)
	endif()
      endif()
    endif()
  endif()
endif()

OPTION(WITH_MYDDAS " Enable MYDDAS DBMS interface" ON)

if (ANDROID)
option (WITH_PACKAGES "packages and libraries  that add value to YAP" OFF)
OPTION(WITH_SWIG " Enable SWIG interfaces to foreign languages" ON)
OPTION(WITH_SQLITE3 " Enable MYDDAS SQLITE3 driver" ON)
else()
 option (WITH_PACKAGES "packages and libraries  that add value to YAP" ON)
 OPTION(WITH_SWIG " Enable SWIG interfaces to foreign languages" ${WITH_PACKAGES})
  OPTION(WITH_SQLITE3 " Enable MYDDAS SQLITE3 driver" ${WITH_PACKAGES})
endif()
  OPTION(WITH_MYSQL " Enable MYDDAS MYSQL driver" ${WITH_MYDDAS}})
OPTION(WITH_ODBC " Enable MYDDAS ODBC driver" ${WITH_MYDDAS})
OPTION(WITH_POSTGRES " Enable MYDDAS POSTGRES driver" ${WITH_MYDDAS})



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_RAPTOR " Enable the RAPTOR RDF library" ${WITH_PACKAGES})
OPTION(WITH_XML2 " Enable the RAPTOR XML2 library" ${WITH_PACKAGES})
OPTION(WITH_XML " Enable the Prolog XML library" ${WITH_PACKAGES})
OPTION(WITH_CLPBN " Enable the CLPBN and PFL probabilistic languages" ${WITH_PACKAGES})
OPTION(WITH_HORUS " Enable the HORUS inference libraray for CLPBN and PFL" ${WITH_CLPBN})
option(WITH_PROBLOG "include Problog-I." ${WITH_PACKAGES})
OPTION(WITH_CPLINT " Enable the cplint probabilistic language" ${WITH_PACKAGES})
option(WITH_GECODE "interface gecode constraint solver" ${WITH_PACKAGES})
option(WITH_LBFGS    "interface  with lbfgs" ${WITH_PACKAGES})
option(WITH_PRISM    "use PRISM system in YAP" ${WITH_PACKAGES})
option(WITH_PYTHON  "Allow Python->YAP  and YAP->Python" ${WITH_PACKAGES})
option(WITH_R  "Use R Interface" ${WITH_PACKAGES})
option(WITH_JAVA "Try to use Java (currently Java )" ${WITH_PACKAGES})

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 ()

if (ANDROID)
function(add_to_dir list output)
  endfunction(add_to_dir 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)

else()
  function(add_to_dir list output)
 endfunction(add_to_dir list output)

endif()

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_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 ($ENV{CONDA_BUILD}x STREQUAL "1x" )
  set(CMAKE_LIBRARY_ARCHITECTURE $ENV{PREFIX})
  set(CMAKE_PREFIX_PATH $ENV{PREFIX})
  set( R_COMMAND "$ENV{R}")
  set_property(DIRECTORY APPEND PROPERTY COMPILE_DEFINITIONS CONDA_BUILD=1)
  set(YAP_IS_MOVABLE 1)

endif()

ADD_CUSTOM_TARGET(run_install COMMAND ${CMAKE_MAKE_PROGRAM} install)

  list (APPEND CMAKE_REQUIRED_INCLUDES
    ${PREFIX}/include
    ${SYS_PREFIX}/include
    )



set(prefix ${CMAKE_INSTALL_PREFIX}) #BINDIR})
set(docdir ${CMAKE_INSTALL_PREFIX}/share/docs) #MANDIR})

set(YAP_ROOTDIR ${prefix})
# erootdir -> rootdir
# libdir defined above
set(YAP_DATADIR  ${CMAKE_INSTALL_FULL_DATADIR})
set(YAP_INCLUDEDIR  ${CMAKE_INSTALL_FULL_INCLUDEDIR}/Yap)
set(YAP_BINDIR  ${CMAKE_INSTALL_FULL_BINDIR})
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_INCLUDEDIR ${CMAKE_INSTALL_INCLUDEDIR}/Yap)
set(YAP_INSTALL_LIBDIR ${CMAKE_INSTALL_LIBDIR}/Yap)
if (ANDROID)
set(YAP_INSTALL_DATADIR ${CMAKE_SOURCE_DIR}/../yaplib/src/generated/assets/Yap)
  else()
set(YAP_INSTALL_DATADIR ${CMAKE_INSTALL_DATADIR}/Yap)
endif()
#
#
# include( Sources  )
#
# include( Model   )

include(cudd )

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)

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


# - Find the readline library
# This module defines
#  READLINE_INCLUDE_DIR, path to readline/readline.h, etc.
#  READLINE_LIBRARIES, the libraries required to use READLINE.
#  READLINE_FOUND, If false, do not try to use READLINE.
# also defined, but not for general use are
# READLINE_readline_LIBRARY, where to find the READLINE library.
# READLINE_ncurses_LIBRARY, where to find the ncurses library [might not be defined]

if (ANDROID)
 option (WITH_READLINE "use Readline" OFF)
 else()

  include(FindReadline)

 option (WITH_READLINE "use Readline" ON)
  # include subdirectories configuration
  ## after we have all functionality in
  #
  # ADD_SUBDIRECTORY(console/terminal)

  if (READLINE_FOUND AND READLINE_INCLUDE_DIR)
  List(APPEND YAP_SYSTEM_OPTIONS readline)
    # required for configure
    include_directories( ${READLINE_INCLUDE_DIR}
      ${READLINE_INCLUDE_DIR}/readline
      )
  endif ()
endif()

include_directories(
${CMAKE_SOURCE_DIR}/H
${CMAKE_SOURCE_DIR}/H/generated
${CMAKE_SOURCE_DIR}/include
${CMAKE_SOURCE_DIR}/os
${CMAKE_SOURCE_DIR}/OPTYap
${CMAKE_SOURCE_DIR}/utf8proc
  ${CMAKE_SOURCE_DIR}/JIT/HPP
  ${GMP_INCLUDE_DIRS}
  ${READLINE_INCLUDE_DIR}
  ${CMAKE_BINARY_DIR}
  ) 

  add_subdirectory( H )

#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 5)
set(YAP_PATCH_VERSION 0)

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)

# 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=1")

# 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>)

# debug across macros
set_property(DIRECTORY APPEND PROPERTY COMPILE_OPTIONS $<$<CONFIG:Debug>:-g3>)

#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 ()

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


# when building, don't use the install RPATH already
## (but later on when installing)
#SET(CMAKE_BUILD_WITH_INSTALL_RPATH FALSE)
#
## SET(CMAKE_INSTALL_FULL_RPATH ${CMAKE_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 FAlSE)
#
#
## the RPATH to be used when installing, but only if it's not a system directory
#LIST(FIND CMAKE_PLATFORM_IMPLICIT_LINK_DIRECTORIES "${YAP_INSTALL_LIBDIR}" isSystemDir)
# IF("${isSystemDir}" STREQUAL "-1")
#    SET(CMAKE_INSTALL_RPATH  ${YAP_INSTALL_LIBDIR})
#ENDIF("${isSystemDir}" STREQUAL "-1")
#
IF(NOT WIN32 AND NOT APPLE)
  LIST(APPEND CMAKE_INSTALL_RPATH \\$ORIGIN/../lib/Yap)
  LIST(APPEND CMAKE_INSTALL_RPATH ${CMAKE_INSTALL_FULL_LIBDIR})
  LIST(APPEND CMAKE_INSTALL_RPATH \\$ORIGIN/../lib)
  LIST(APPEND CMAKE_INSTALL_RPATH \\$ORIGIN/../../../lib)
ELSE()
  LIST(APPEND CMAKE_INSTALL_RPATH @loader_path/../lib/Yap)
  LIST(APPEND CMAKE_INSTALL_RPATH ${CMAKE_INSTALL_FULL_LIBDIR})
  LIST(APPEND CMAKE_INSTALL_RPATH @loader_path/../lib)
  LIST(APPEND CMAKE_INSTALL_RPATH @loader_path/../../../lib)
ENDIF()

set(YAP_STARTUP startup.yss)
set(YAP_SOURCEBOOT boot.yap   )

# 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-pointer;-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
  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)

#TODO:
#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)

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


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


IF (WITH_R)
  find_host_package(LibR)
  add_subDIRECTORY(packages/real)
 ENDIF (WITH_R)


include(Sources)


ADD_SUBDIRECTORY(OPTYap)
ADD_SUBDIRECTORY(os)
ADD_SUBDIRECTORY(library/dialect/swi/fli)
ADD_SUBDIRECTORY(CXX)

ADD_SUBDIRECTORY(pl)

ADD_SUBDIRECTORY(library)

ADD_SUBDIRECTORY(swi/library)

add_subDIRECTORY(utf8proc )



   if(ANDROID)

       set(CXX_SWIG_OUTDIR ${CMAKE_BINARY_DIR}/packages/swig/android)
       add_subdirectory(packages/swig/android)
       add_definitions(-DMYDDAS=1 -DEMBEDDED_MYDDAS=1 -DMYDDAS_SQLITE3=1 -DEMBEDDED_SQLITE3=1)
       link_directories(${CMAKE_SOURCE_DIR}/../sqlite-android/jni/${CMAKE_ANDROID_ARCH_ABI})

   else()
       add_definitions(-DMYDDAS=1 -DEMBEDDED_MYDDAS=1 -DMYDDAS_SQLITE3=1 )

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

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

    if (POSTGRES_FOUND)
      add_definitions( -DMYDDAS_POSTGRES=1)
  endif()
#utf-8 is not aPconn option
# we use the nice UTF-8 package
#available at the Julia project


add_subDIRECTORY( packages/myddas )
add_subDIRECTORY( packages/clpqr )


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 OR ANDROID)
  List(APPEND YLIBS $<TARGET_OBJECTS:YAP++>)
  if (WIN32 AND WITH_PYTHON)
    List(APPEND YLIBS $<TARGET_OBJECTS:Py4YAP>)
    list (APPEND WINDLLS ${PYTHON_LIBRARIES})
  endif ()
  if (ANDROID)
    List(APPEND YLIBS $<TARGET_OBJECTS:YAPsqlite3>)
    List(APPEND YLIBS $<TARGET_OBJECTS:DROID>)
  set(ANDROID_LIBRARIES sqliteX  android log)

  endif ()
endif ()


add_library( # 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}
  )

  target_link_libraries(libYap
    m
    ${GMP_LIBRARIES}
    ${READLINE_LIBRARIES}
    ${ANDROID_LIBRARIES}
    ${WINDLLS}
    ${PYTHON_LIBRARIES}
    )

  set_target_properties(libYap
  PROPERTIES OUTPUT_NAME 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)


if (ANDROID)
  include_directories(CXX ${CMAKE_SOURCE_DIR}/../yaplib/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}
  )



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

if (WITH_PYTHON AND PYTHONLIBS_FOUND AND SWIG_FOUND)
  set( ENV{PYTHONPATH} ${CMAKE_BINARY_DIR}/packages/python/swig:${CMAKE_BINARY_DIR}/packages/python/yap_kernel:. )
  add_subdirectory(packages/python/swig)

  include(FindPythonModule)

  find_python_module(jupyter)
  find_python_module(wheel)
  find_python_module(setuptools)
  if (PY_JUPYTER AND PY_WHEEL AND PY_SETUPTOOLS)
    add_subdirectory(packages/python/yap_kernel)
  else()
    message("will not compile yap_kernel, as jupyter=${PY_JUPYTER};wheel=${PY_WHEEL};setuptools=${PY_SETUPTOOLS}")
  ENDIF ()

endif ()



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


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


if (WITH_JIT)
  add_subDIRECTORY(JIT)
endif (WITH_JIT)


if (WITH_XML2 OR WITH_RAPTOR)

  add_subDIRECTORY(packages/raptor)

endif()


if (WITH_XML)

  add_subDIRECTORY(packages/xml)

endif ()


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

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


IF (WITH_DOCS)
  get_target_property(YAP_SOURCES libYap SOURCES)

  add_subDIRECTORY(docs)


  find_host_package(Doxygen)

ENDIF (WITH_DOCS)

# add_subDIRECTORY (packages/cuda)

if (WITH_GECODE)
  add_subDIRECTORY(packages/gecode)
endif ()

if (WITH_LBFGS)
  add_subDIRECTORY(packages/yap-lbfgs)
endif ()




if (WITH_JAVA)
  #detect java setup, as it is shared between different installations.

  find_package(Java COMPONENTS Development Runtime)
  # find_package(Java COMPONENTS Development)
  # find_package(Java COMPONENTS Runtime)
  #find_package(JavaLibs)


  if (Java_Development_FOUND)

    set (STD_CMAKE_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK})
    set (CMAKE_FIND_FRAMEWORK LAST) # CMake will find the Java returned by /usr/libexec/java_home.

    macro_optional_find_package(JNI ON)


    set (CMAKE_FIND_FRAMEWORK ${STD_CMAKE_FIND_FRAMEWORK})

    if (JNI_FOUND)

      get_filename_component(JAVA_HOME ${JAVA_INCLUDE_PATH} DIRECTORY)

      include(UseJava)

      #
      #   Java_JAVA_EXECUTABLE      = the full path to the Java runtime
      #   Java_JAVAC_EXECUTABLE     = the full path to the Java compiler
      #   Java_JAVAH_EXECUTABLE     = the full path to the Java header generator
      #   Java_JAVADOC_EXECUTABLE   = the full path to the Java documention generator
      #   Java_IDLJ_EXECUTABLE      = the full path to the Java idl compiler
      #   Java_JAR_EXECUTABLE       = the full path to the Java archiver
      #   Java_JARSIGNER_EXECUTABLE = the full path to the Java jar signer
      #   Java_VERSION_STRING       = Version of java found, eg. 1.6.0_12
      #   Java_VERSION_MAJOR        = The major version of the package found.
      #   Java_VERSION_MINOR        = The minor version of the package found.
      #   Java_VERSION_PATCH        = The patch version of the package found.
      #   Java_VERSION_TWEAK        = The tweak version of the package found (after '_')
      #   Java_VERSION              = This is set to: $major.$minor.$patch(.$tweak)
      #
      # The Java_ADDITIONAL_VERSIONS variable can be used to specify a list
      # of version numbers that should be taken into account when searching
      # for Java.  You need to set this variable before calling


      #
      #macro_optional_find_package(JNI ON)
      #   JNI_INCLUDE_DIRS      = the include dirs to use
      #   JNI_LIBRARIES         = the libraries to use
      #   JNI_FOUND             = TRUE if JNI headers and libraries were found.
      #   JAVA_AWT_LIBRARY      = the path to the jawt library
      #   JAVA_JVM_LIBRARY      = the path to the jvm library
      #   JAVA_INCLUDE_PATH     = the include path to jni.h
      #   JAVA_INCLUDE_PATH2    = the include path to jni_md.h
      #   JAVA_AWT_INCLUDE_PATH = the include path to jawt.h



  get_filename_component ( JAVA_AWT_DIR ${JAVA_AWT_LIBRARY} DIRECTORY)
  get_filename_component ( JAVA_JNI_DIR ${JAVA_JVM_LIBRARY} DIRECTORY)
  list(APPEND CMAKE_INSTALL_RPATH ${JAVA_AWT_DIR};${JAVA_JNI_DIR})
if (APPLE)
  set(CMAKE_MACOSX_RPATH 1)
  find_library (JLI jli ${JAVA_AWT_DIR}/jli)
  #find_library (JAL JavaApplicationLauncher FRAMEWORK ONLY PATH /System/Library/PrivateFrameworks)
  #find_library (JL JavaLaunching FRAMEWORK ONLY PATH /System/Library/PrivateFrameworks)
  list(APPEND CMAKE_INSTALL_RPATH ${JAVA_AWT_DIR}/jli)
list(APPEND JNI_LIBRARIES  ${JLI};${JAL};${JL})
endif()

    endif (JNI_FOUND)


  endif (Java_Development_FOUND)

  add_subDIRECTORY(packages/jpl)

endif(WITH_JAVA)

if (WITH_CUDD)

  add_subDIRECTORY(packages/bdd)

endif()

if (WITH_PROBLOG)

  add_subDIRECTORY(packages/ProbLog)

endif()

if (WITH_MINISAT)

  add_subDIRECTORY(packages/swi-minisat2)

endif()

if (WITH_CLPQR)

  add_subDIRECTORY(packages/clpqr)

endif()


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

# 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" ON)

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

#TODO:


#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}
  )


if (WITH_MPI)

  add_subDIRECTORY(library/lammpi)

  if (MPI_C_FOUND)

    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(WITH_MPI)

##   add_subDIRECTORY(utils)

#

install(FILES ${INCLUDE_HEADERS} ${CONFIGURATION_HEADERS} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/Yap )

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

include(Config )


feature_summary(DESCRIPTION "Packages found:"
  WHAT  PACKAGES_FOUND
  )
feature_summary(DESCRIPTION "Packages not found:"
  WHAT  PACKAGES_NOT_FOUND
  )