CMakeLists.vendor

# minimal cmake version
cmake_minimum_required(VERSION 3.20)

# this shouldn't be necessary
set(CMAKE_PREFIX_PATH "${CMAKE_PREFIX_PATH};${CMAKE_SOURCE_DIR}/vendor/local")
link_directories(${CMAKE_SOURCE_DIR}/vendor/local/lib)

# fallback for other versions 
if(${CMAKE_VERSION} VERSION_LESS 3.20)
    cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION})
else()
    cmake_policy(VERSION 3.20) 
endif()

message("generator: ${CMAKE_GENERATOR}")

# set the cxx compiler standard
set(CMAKE_CXX_STANDARD 23)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS ON)

# steal the version of the interpreter
set(VERSION_MAJOR_REGEX "#define EXECUTABLE_VERSION_MAJOR[ \t]+\"(.+)\"")
set(VERSION_MINOR_REGEX "#define EXECUTABLE_VERSION_MINOR[ \t]+\"(.+)\"")
set(VERSION_PATCH_REGEX "#define EXECUTABLE_VERSION_PATCH[ \t]+\"(.+)\"")

file(STRINGS "${CMAKE_SOURCE_DIR}/src/egel.cpp"
    VERSION_MAJOR REGEX ${VERSION_MAJOR_REGEX})
file(STRINGS "${CMAKE_SOURCE_DIR}/src/egel.cpp"
    VERSION_MINOR REGEX ${VERSION_MINOR_REGEX})
file(STRINGS "${CMAKE_SOURCE_DIR}/src/egel.cpp"
    VERSION_PATCH REGEX ${VERSION_PATCH_REGEX})

string(REGEX REPLACE ${VERSION_MAJOR_REGEX} "\\1" VERSION_MAJOR "${VERSION_MAJOR}")
string(REGEX REPLACE ${VERSION_MINOR_REGEX} "\\1" VERSION_MINOR "${VERSION_MINOR}")
string(REGEX REPLACE ${VERSION_PATCH_REGEX} "\\1" VERSION_PATCH "${VERSION_PATCH}")

set(PVERSION ${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH})

# report findings
message("egel version: ${PVERSION}")

# current dirs
message("Current binary directory: ${CMAKE_CURRENT_BINARY_DIR}")
message("Current source directory: ${CMAKE_CURRENT_SOURCE_DIR}")
execute_process(COMMAND pwd OUTPUT_VARIABLE current_dir OUTPUT_STRIP_TRAILING_WHITESPACE)
message("Current working directory: ${current_dir}")

# contents of this
message("Files of current dir")
file(GLOB FILES_IN_DIR "*")
foreach(FILE ${FILES_IN_DIR})
    message("${FILE}")
endforeach()
# contents of vendor/local/lib
message("Files in vendor/local/lib")
file(GLOB FILES_IN_DIR "vendor/local/lib/*")
foreach(FILE ${FILES_IN_DIR})
    message("${FILE}")
endforeach()

# the Egel project
project(Egel DESCRIPTION "The Egel interpreter"
        VERSION ${PVERSION} LANGUAGES CXX)

# set the cxx compiler flags
if(NOT CMAKE_BUILD_TYPE)
  set(CMAKE_BUILD_TYPE Release)
endif()

# compilers
message("compiler: ${CMAKE_CXX_COMPILER_ID}")
if(("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang"))
  set(CMAKE_CXX_FLAGS                     "-Wall -Wextra -Werror -pedantic -Wno-unused-parameter -Wno-return-type-c-linkage")
  set(CMAKE_CXX_FLAGS_DEBUG               "-g")
  set(CMAKE_CXX_FLAGS_RELEASE             "-Ofast")

  set(CMAKE_CXX_FLAGS_PROFILE             "-Ofast -fprofile-instr-generate -fcoverage-mapping")
  #set(CMAKE_EXE_LINKER_FLAGS_PROFILE      "-O3 -pg")
  #set(CMAKE_SHARED_LINKER_FLAGS_PROFILE   "-O3 -pg")
elseif(("${CMAKE_CXX_COMPILER_ID}" MATCHES "AppleClang"))
  set(CMAKE_CXX_FLAGS                     "-Wall -Wextra -Werror -pedantic -Wno-unused-parameter -Wno-return-type-c-linkage")
  set(CMAKE_CXX_FLAGS_DEBUG               "-g")
  set(CMAKE_CXX_FLAGS_RELEASE             "-Ofast")

  #set(CMAKE_CXX_FLAGS_PROFILE             "-O3 -pg")
  #set(CMAKE_EXE_LINKER_FLAGS_PROFILE      "-O3 -pg")
  #set(CMAKE_SHARED_LINKER_FLAGS_PROFILE   "-O3 -pg")
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
  set(CMAKE_CXX_FLAGS                     "-Wall -Wextra -Werror -pedantic -Wno-unused-parameter")
  set(CMAKE_CXX_FLAGS_DEBUG               "-g")
  set(CMAKE_CXX_FLAGS_RELEASE             "-O3")

  #set(CMAKE_CXX_FLAGS_PROFILE             "-O3 -pg")
  #set(CMAKE_EXE_LINKER_FLAGS_PROFILE      "-O3 -pg")
  #set(CMAKE_SHARED_LINKER_FLAGS_PROFILE   "-O3 -pg")
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Intel")
  set(CMAKE_CXX_FLAGS                     "-Wall -Wextra -Werror -pedantic -Wno-unused-parameter")
  set(CMAKE_CXX_FLAGS_DEBUG               "-g")
  set(CMAKE_CXX_FLAGS_RELEASE             "-O3")

  set(CMAKE_CXX_FLAGS_PROFILE             "-O3 -pg")
  set(CMAKE_EXE_LINKER_FLAGS_PROFILE      "-O3 -pg")
  set(CMAKE_SHARED_LINKER_FLAGS_PROFILE   "-O3 -pg")
elseif (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
  set(CMAKE_CXX_FLAGS                     "-Wall -Wextra -Werror -pedantic -Wno-unused-parameter")
  set(CMAKE_CXX_FLAGS_DEBUG               "-g")
  set(CMAKE_CXX_FLAGS_RELEASE             "-O3")

  set(CMAKE_CXX_FLAGS_PROFILE             "-O3 -pg")
  set(CMAKE_EXE_LINKER_FLAGS_PROFILE      "-O3 -pg")
  set(CMAKE_SHARED_LINKER_FLAGS_PROFILE   "-O3 -pg")
else()
  set(CMAKE_CXX_FLAGS                     "-Wall -Wextra -Werror -pedantic -Wno-unused-parameter")
  set(CMAKE_CXX_FLAGS_DEBUG               "-g")
  set(CMAKE_CXX_FLAGS_RELEASE             "-O3")

  set(CMAKE_CXX_FLAGS_PROFILE             "-O3 -pg")
  set(CMAKE_EXE_LINKER_FLAGS_PROFILE      "-O3 -pg")
  set(CMAKE_SHARED_LINKER_FLAGS_PROFILE   "-O3 -pg")
endif()

# for the moment, glob sources and headers
file(GLOB EGEL_SOURCES CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/src/*.cpp")
file(GLOB EGEL_HEADERS CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/src/*.hpp")

# check for Threads, fmt, ffi, icu4c, and GNU lightning
find_package(Threads REQUIRED)

include_directories("${CMAKE_SOURCE_DIR}/src") # egel
include_directories(vendor/local/include) # vendor

find_library(ICUI18N NAMES icui18n PATHS vendor/local/lib NO_DEFAULT_PATH)
find_library(ICUDATA NAMES icudata PATHS vendor/local/lib NO_DEFAULT_PATH)
find_library(ICUIO   NAMES icuio   PATHS vendor/local/lib NO_DEFAULT_PATH)
find_library(ICUTU   NAMES icutu   PATHS vendor/local/lib NO_DEFAULT_PATH)
find_library(ICUUC   NAMES icuuc   PATHS vendor/local/lib NO_DEFAULT_PATH)

message("icui18n: ${ICUI18N}")
message("icudata: ${ICUDATA}")
message("icuio:   ${ICUIO}")
message("icutu:   ${ICUTU}")
message("icuuc:   ${ICUUC}")

find_library(FFI NAMES ffi PATHS vendor/local/lib NO_DEFAULT_PATH)

message("ffi: ${FFI}")

find_library(LIGHTNING NAMES lightning PATHS vendor/local/lib NO_DEFAULT_PATH)

message("lightning: ${LIGHTNING}")

find_library(FMT NAMES fmt PATHS vendor/local/lib NO_DEFAULT_PATH)

message("fmt: ${FMT}")

# setup rpath
include(GNUInstallDirs)
set(CMAKE_MACOSX_RPATH 1) # heh?
list( APPEND CMAKE_INSTALL_RPATH ${CMAKE_INSTALL_LIBDIR} )

# make the IDE aware of include path, etc.
set( CMAKE_EXPORT_COMPILE_COMMANDS ON )

# objects
add_library(objlib OBJECT ${EGEL_SOURCES})
set_property(TARGET objlib PROPERTY POSITION_INDEPENDENT_CODE 1)
target_link_libraries(objlib PRIVATE Threads::Threads ${FFI} ${ICUUC} ${ICUI18N} ${ICUIO} ${ICUDATA} ${ICUTU} ${FMT} ${LIGHTNING})

# the Egel interpreter
add_executable(egel $<TARGET_OBJECTS:objlib>)
target_link_libraries(egel PRIVATE ${CMAKE_DL_LIBS} Threads::Threads ${FFI} ${ICUTU} ${ICUI18N} ${ICUIO} ${ICUDATA} ${ICUUC} ${FMT} ${LIGHTNING})

# shared Egel library
add_library(egellib SHARED $<TARGET_OBJECTS:objlib>)
set_target_properties(egellib PROPERTIES OUTPUT_NAME egel)
target_link_libraries(egellib PRIVATE Threads::Threads ${FFI} ${ICUUC} ${ICUI18N} ${ICUIO} ${ICUDATA} ${ICUTU} ${FMT} ${LIGHTNING})

# static Egel library
add_library(egellib_static STATIC $<TARGET_OBJECTS:objlib>)
set_target_properties(egellib_static PROPERTIES OUTPUT_NAME egel)
target_link_libraries(egellib_static PRIVATE Threads::Threads ${FFI} ${ICUUC} ${ICUI18N} ${ICUIO} ${ICUDATA} ${ICUTU} ${FMT} ${LIGHTNING})

#
# the dynamic .ego Egel libraries

# random.ego
file(GLOB RANDOM_LIST CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/lib/random/*.cpp")
add_library(random MODULE ${RANDOM_LIST})
target_link_libraries(random PRIVATE Threads::Threads ${ICUUC} ${ICUI18N} ${ICUIO} ${ICUDATA} ${ICUTU} ${FMT} ${LIGHTNING})
set_target_properties(random PROPERTIES PREFIX "" SUFFIX ".ego")

# pqueue.ego
file(GLOB DICT_LIST CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/lib/pqueue/*.cpp")
add_library(pqueue MODULE ${DICT_LIST})
target_link_libraries(pqueue PRIVATE Threads::Threads ${ICUUC} ${ICUI18N} ${ICUIO} ${ICUDATA} ${ICUTU} ${FMT} ${LIGHTNING})
set_target_properties(pqueue PROPERTIES PREFIX "" SUFFIX ".ego")

# installation

install(TARGETS egel
        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)

install(TARGETS egellib egellib_static
        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
)

# a bit unfortunate but you need to include the ICU version major number
file(GLOB ICULIBS CONFIGURE_DEPENDS 
    "${CMAKE_SOURCE_DIR}/vendor/local/lib/*icu*.so"
    "${CMAKE_SOURCE_DIR}/vendor/local/lib/*icu*.dylib"
)
install(FILES ${ICULIBS}
        DESTINATION ${CMAKE_INSTALL_LIBDIR}
)

file(GLOB FFILIBS CONFIGURE_DEPENDS 
    "${CMAKE_SOURCE_DIR}/vendor/local/lib/*ffi*.so"
    "${CMAKE_SOURCE_DIR}/vendor/local/lib/*ffi*.dylib"
)
install(FILES ${FFILIBS}
        DESTINATION ${CMAKE_INSTALL_LIBDIR}
)

file(GLOB FMTLIB CONFIGURE_DEPENDS 
    "${CMAKE_SOURCE_DIR}/vendor/local/lib/*fmt*.so"
    "${CMAKE_SOURCE_DIR}/vendor/local/lib/*fmt*.dylib"
)
install(FILES ${FMTLIB}
        DESTINATION ${CMAKE_INSTALL_LIBDIR}
)

file(GLOB LIGHTNINGLIB CONFIGURE_DEPENDS 
    "${CMAKE_SOURCE_DIR}/vendor/local/lib/*lightning.so"
    "${CMAKE_SOURCE_DIR}/vendor/local/lib/*lightning.dylib"
)
install(FILES ${LIGHTNINGLIB}
        DESTINATION ${CMAKE_INSTALL_LIBDIR}
)

install(FILES ${EGEL_HEADERS}
        DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/egel
)

file(GLOB INCLUDE_LIST CONFIGURE_DEPENDS "${CMAKE_SOURCE_DIR}/include/*.eg")
install(FILES ${INCLUDE_LIST}
	DESTINATION  "${CMAKE_INSTALL_LIBDIR}/egel"
)

install(TARGETS random pqueue
	DESTINATION  "${CMAKE_INSTALL_LIBDIR}/egel"
)

install(FILES "${CMAKE_SOURCE_DIR}/man/egel.1"
        DESTINATION ${CMAKE_INSTALL_MANDIR}/man1
)