CMakeLists.txt

cmake_minimum_required(VERSION 3.17)
include(TestBigEndian) # Needed for endianness tests

set(LKT_VERSION 2.4)

# Alpho Vivy, CXX only
project(lektor VERSION ${LKT_VERSION} LANGUAGES C)
cmake_policy(SET CMP0100 NEW)
cmake_policy(SET CMP0009 NEW)
set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/utils/cmake/")
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
set(THREADS_PREFER_PTHREAD_FLAG     ON)
SET(CMAKE_COLOR_MAKEFILE            ON)

set(COMMON_C_FLAGS
    -Wall -Wextra -Werror
    -Wshadow
    -Wcast-align
    -Wconversion
    -Wsign-conversion
    -Wunused-variable
    -Wmisleading-indentation
    -Wnull-dereference
    -Wdouble-promotion
    -Wformat=2
    -Wignored-qualifiers

    -fopenmp
)

set(clang_C_FLAGS
    -Weverything
    -Wpedantic
    -Wno-extra-semi-stmt
    -Wno-reserved-id-macro
    -Wno-reserved-identifier
    -Wno-used-but-marked-unused
    -Wno-unused-macros
    -Wno-cast-qual
    -Wno-macro-redefined
    -Wno-padded
    -Wno-vla
    -Wno-disabled-macro-expansion
    -Wno-extra-semi
    -Wno-format-nonliteral
    -Wno-missing-variable-declarations
    -Wno-unknown-warning-option
)

set(gnu_C_FLAGS)

# Find dependencies
find_library(MPV_LIBRARY        mpv         REQUIRED)                   # tested with 0.32.0
find_library(SQLITE3_LIBRARY    sqlite3     REQUIRED version>=3.31.0)   # tested with 3.34.1

find_package(SDL2                           REQUIRED version>=2.0)      # tested with 2.0.14
find_package(SDL2_image                     REQUIRED version>=2.0)      # same as above ^
find_package(CURL                           REQUIRED HTTP HTTPS)        # tested with 7.74.0

find_program(MKVPROPEDIT        mkvpropedit REQUIRED)   # To DL karas and apply metadata
find_program(XXD                xxd         REQUIRED)   # To embed the sqlite db schemas into the binary

TEST_BIG_ENDIAN(IS_BIG_ENDIAN)
if(IS_BIG_ENDIAN)
    set(LKT_ENDIANES_BIG 1)
    message(STATUS "Building lektor on ${CMAKE_SYSTEM_PROCESSOR} - big endian")
else()
    set(LKT_ENDIANES_LITTLE 1)
    message(STATUS "Building lektor on ${CMAKE_SYSTEM_PROCESSOR} - little endian")
endif()

# Don't forget for specific things
if(WIN32)
    message(STATUS "You are building on windows, pay attenion to the dependencies")
    set(GENERATE_MANPAGES 0)
endif()
if(MSVC OR MSYS OR MINGW)
    message(STATUS "You are building with a windows compiler")
    set(GENERATE_MANPAGES 0)
endif()
if(APPLE)
    message(STATUS "You are building on MacOS X")
    find_program(MAN man REQUIRED)
    set(GENERATE_MANPAGES 1)
endif()
if(UNIX AND NOT APPLE)
    message(STATUS "You are building on Linux, FreeBSD or any other toaster OS")
    find_program(MAN man REQUIRED)
    set(GENERATE_MANPAGES 1)
endif()

##################
# Grab all files #
##################

set(lektor_db_SOURCES
    src/database/queue.c
    src/database/config.c
    src/database/playlist.c
    src/database/find.c
    src/database/user.c
    src/database/stickers.c
    src/database/cache.c
    src/database/open.c
    src/database/update.c
    src/database/upgrade.c
)

set(lektor_module_SOURCES
    src/base/reg.c
    src/module/module_repo.c
    src/module/mpv.c
    src/module/module_sdl2.c
    src/module/worker.c
)

set(lektor_mkv_SOURCES
    src/mkv/utils.c
    src/mkv/write.c
    src/mkv/mkv.c
    src/base/bufferfd.c
)

set(lektor_base_SOURCES
    src/base/config.c
    src/base/logfile.c
    src/base/launch.c
    src/base/stack.c
    src/base/json.c
    src/base/common.c
    src/base/segv.c
    src/base/cmd.c
    src/base/uri.c
    src/base/commands.c
    src/base/os.c
)

set(lektor_net_SOURCES
    src/net/command.c
    src/net/listen.c
    src/net/message.c
)

set(lektord_SOURCES
    src/main/server.c
    ${lektor_net_SOURCES}
    ${lektor_base_SOURCES}
    ${lektor_mkv_SOURCES}
    ${lektor_module_SOURCES}
    ${lektor_db_SOURCES}
)

set(lkt_SOURCES
    src/main/lkt.c
    src/base/common.c
    src/base/segv.c
    src/base/cmd.c
)

set(luka_SOURCES
    src/main/luka.c
    ${lektor_net_SOURCES}
    ${lektor_base_SOURCES}
    ${lektor_module_SOURCES}
    ${lektor_db_SOURCES}
    ${lektor_mkv_SOURCES}
)

set(common_HEADERS
    <stdnoreturn.h>
    <endian.h>
    <inttypes.h>
    <locale.h>
    <memory.h>
    <regex.h>
    <stddef.h>
    <unistd.h>
    <stdint.h>
    <stdlib.h>
    <strings.h>
    <string.h>
    <memory.h>
    <limits.h>
    <stdbool.h>
    <stdarg.h>
    <errno.h>
    <pthread.h>
    <stdio.h>
    <time.h>
    <ctype.h>
    <fcntl.h>
    <endian.h>
    <sys/stat.h>
    <sys/types.h>
    <sys/time.h>
)

set(common_DEFINITIONS
    LKT_ARCH="${CMAKE_SYSTEM_PROCESSOR}"
    LKT_MAN_BINARY="${MAN}"
    LKT_ENDIANES_BIG=${LKT_ENDIANES_BIG}
    LKT_ENDIANES_LITTLE=${LKT_ENDIANES_LITTLE}
    LKT_STATIC_MODULE=1 # Only build static modules with cmake
    _POSIX_C_SOURCE=200809L # POSIX 2008/09
    LKT_VERSION="${LKT_VERSION}"
)

set(SQL_GENERATED_FILE ${CMAKE_CURRENT_BINARY_DIR}/disk_sql.c)
set(SQL_SOURCE_FILES
    ${CMAKE_CURRENT_SOURCE_DIR}/src/database/disk.sql
    ${CMAKE_CURRENT_SOURCE_DIR}/src/database/memory.sql
)

#######################
# Set all the targets #
#######################

add_custom_command(OUTPUT ${SQL_GENERATED_FILE}
    COMMAND ${CMAKE_COMMAND} -E touch ${SQL_GENERATED_FILE}
    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}

    COMMAND ${CMAKE_COMMAND} -E echo 'unsigned char ___src_database_disk_sql[] = { '              >  ${SQL_GENERATED_FILE}
    COMMAND ${XXD} -i < ${CMAKE_CURRENT_SOURCE_DIR}/src/database/disk.sql                         >> ${SQL_GENERATED_FILE}
    COMMAND ${CMAKE_COMMAND} -E echo ', 0x00 }\; unsigned char ___src_database_memory_sql[] = { ' >> ${SQL_GENERATED_FILE}
    COMMAND ${XXD} -i < ${CMAKE_CURRENT_SOURCE_DIR}/src/database/memory.sql                       >> ${SQL_GENERATED_FILE}
    COMMAND ${CMAKE_COMMAND} -E echo ', 0x00 }\;'                                                 >> ${SQL_GENERATED_FILE}

    DEPENDS ${SQL_SOURCE_FILES}
    COMMENT "Generating SQL included files to embed them"
)

add_executable(lektord ${lektord_SOURCES} ${SQL_GENERATED_FILE})
add_executable(lkt     ${lkt_SOURCES})
add_executable(luka    ${luka_SOURCES} ${SQL_GENERATED_FILE})

if(GENERATE_MANPAGES)
    message(STATUS "Generating manpages")
    set(MANPAGE_COMMANDS lkt lektord lektor luka)

    foreach(CMD IN LISTS MANPAGE_COMMANDS)
        add_custom_target(manpage_cmd_${CMD} ALL
            COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/utils/scripts/manpage.bash ${CMAKE_CURRENT_SOURCE_DIR}/man/${CMD}.template ${CMAKE_CURRENT_BINARY_DIR}/${CMD}.1 ${CMAKE_CURRENT_SOURCE_DIR}/man/footer
            DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/man/${CMD}.template ${CMAKE_CURRENT_SOURCE_DIR}/man/footer
            COMMENT "Generating manpage for command ${CMD}"
        )
    endforeach()
endif()

target_link_libraries(lektord PRIVATE
    ${MPV_LIBRARY}
    ${CMAKE_DL_LIBS}
    ${SQLITE3_LIBRARY}
    ${SDL2_LIBRARIES}
    ${CURL_LIBRARIES}
    ${SDL2_IMAGE_LIBRARIES}
)
target_link_libraries(luka PRIVATE
    ${MPV_LIBRARY}
    ${CMAKE_DL_LIBS}
    ${SQLITE3_LIBRARY}
    ${SDL2_LIBRARIES}
    ${CURL_LIBRARIES}
    ${SDL2_IMAGE_LIBRARIES}
)

target_include_directories(lkt     PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/inc)
target_include_directories(luka    PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}/inc
    ${SDL2_INCLUDE_DIRS}
    ${SDL2_IMAGE_INCLUDE_DIRS}
    ${CURL_INCLUDE_DIRS}
)
target_include_directories(lektord PRIVATE
    ${CMAKE_CURRENT_SOURCE_DIR}/inc
    ${SDL2_INCLUDE_DIRS}
    ${SDL2_IMAGE_INCLUDE_DIRS}
    ${CURL_INCLUDE_DIRS}
)

target_compile_options(lektord     PRIVATE ${COMMON_C_FLAGS})
target_compile_options(lkt         PRIVATE ${COMMON_C_FLAGS})
target_compile_options(luka        PRIVATE ${COMMON_C_FLAGS})

target_link_libraries(lektord      PRIVATE -fopenmp)
target_link_libraries(luka         PRIVATE -fopenmp)

target_compile_definitions(lektord PRIVATE ${common_DEFINITIONS})
target_compile_definitions(lkt     PRIVATE ${common_DEFINITIONS})
target_compile_definitions(luka    PRIVATE ${common_DEFINITIONS})

target_precompile_headers(lektord  PRIVATE ${common_HEADERS})
target_precompile_headers(lkt      PRIVATE ${common_HEADERS})
target_precompile_headers(luka     PRIVATE ${common_HEADERS})

if (${CMAKE_C_COMPILER_ID} STREQUAL "Clang")
    target_compile_options(lektord PRIVATE ${clang_C_FLAGS})
    target_compile_options(lkt     PRIVATE ${clang_C_FLAGS})
    target_compile_options(luka    PRIVATE ${clang_C_FLAGS})

    # Force the color output
    add_compile_options(-fcolor-diagnostics)
elseif (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
    target_compile_options(lektord PRIVATE ${gnu_C_FLAGS})
    target_compile_options(lkt     PRIVATE ${gnu_C_FLAGS})
    target_compile_options(luka    PRIVATE ${gnu_C_FLAGS})

    # Force the color output
    add_compile_options(-fdiagnostics-color=always)
endif()