CMakeLists.txt

PROJECT("cbase" C)

CMAKE_MINIMUM_REQUIRED(VERSION 2.9.0 FATAL_ERROR)

INCLUDE(CheckCCompilerFlag)
INCLUDE(CheckFunctionExists)
INCLUDE(CheckIncludeFiles)
INCLUDE(CheckSymbolExists)
INCLUDE(TestBigEndian)

CMAKE_POLICY(SET CMP0042 NEW)

IF(${CMAKE_BINARY_DIR} STREQUAL ${CMAKE_SOURCE_DIR})
  MESSAGE(FATAL_ERROR "Cannot build source in-tree.")
ENDIF()

SET(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build type")
SET_PROPERTY(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Release" "Debug")

IF((NOT DEFINED CMAKE_BUILD_TYPE) OR (CMAKE_BUILD_TYPE STREQUAL ""))
  SET(CMAKE_BUILD_TYPE "Release")
ENDIF()

IF(CMAKE_BUILD_TYPE STREQUAL "Release")
  SET(DEBUGGING FALSE)
ELSEIF(CMAKE_BUILD_TYPE STREQUAL "Debug")
  SET(DEBUGGING TRUE)
ELSE()
  MESSAGE(FATAL_ERROR "Unknown build type ${CMAKE_BUILD_TYPE}")
ENDIF()

SET(CMAKE_EXPORT_COMPILE_COMMANDS OFF CACHE BOOL
  "Export compile_commands.json"
)

SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules)

SET(VERSION "0")
SET(PACKAGE "cbase")
SET(PACKAGE_NAME "cbase")
SET(PACKAGE_VERSION "${VERSION}")
SET(PACKAGE_STRING "${PACKAGE_NAME} v${PACKAGE_VERSION}")
SET(PACKAGE_TARNAME "cbase")
SET(PACKAGE_URL "http://github.com/camgunz/cbase")

SET(CPACK_GENERATOR "DEB;RPM;STGZ;ZIP")
SET(CPACK_PACKAGE_VENDOR "Team TotalTrash")
SET(CPACK_PACKAGE_CONTACT "Team TotalTrash <charles.gunyon@gmail.com>")
SET(CPACK_PACKAGE_VERSION "${VERSION}")
SET(CPACK_PACKAGE_NAME "${PACKAGE_TARNAME}")
SET(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_SOURCE_DIR}/COPYING")
SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY
  "A library of simple data structures"
)
SET(CPACK_DEBIAN_PACKAGE_SECTION "devel")
SET(CPACK_DEBIAN_PACKAGE_DEPENDS "libc6 (>= 2.4)")
SET(CPACK_DEBIAN_PACKAGE_DEPENDS "libutf8proc-dev (>= 2.3.0)")

IF(${CMAKE_SYSTEM_PROCESSOR} MATCHES "i686")
  SET(CPACK_DEBIAN_PACKAGE_ARCHITECTURE "i386")
  SET(CPACK_RPM_PACKAGE_ARCHITECTURE "i686" )
  SET(BUILD_ARCH "${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}")
ELSEIF(${CMAKE_SYSTEM_PROCESSOR} MATCHES "x86_64")
  SET(CPACK_DEBIAN_PACKAGE_ARCHITECTURE "amd64")
  SET(CPACK_RPM_PACKAGE_ARCHITECTURE "x86_64" )
  SET(BUILD_ARCH "${CPACK_DEBIAN_PACKAGE_ARCHITECTURE}")
ELSEIF(WIN32)
  SET(BUILD_ARCH "windows-x86")
  IF("$ENV{PROCESSOR_ARCHITECTURE}" STREQUAL "AMD64")
    SET(BUILD_ARCH "windows-$ENV{PROCESSOR_ARCHITECTURE}")
  ENDIF()
ELSE()
  SET(BUILD_ARCH "${CMAKE_SYSTEM_PROCESSOR}")
ENDIF()

SET(CPACK_PACKAGE_FILE_NAME
  "${CPACK_PACKAGE_NAME}-v${CPACK_PACKAGE_VERSION}_${BUILD_ARCH}"
)
SET(CPACK_DEBIAN_PACKAGE_NAME "${CPACK_PACKAGE_FILE_NAME}")
SET(CPACK_RPM_PACKAGE_NAME "${CPACK_PACKAGE_FILE_NAME}")

IF(CMAKE_C_COMPILER_ID STREQUAL "Clang")
  SET(CLANG TRUE)
ELSE()
  SET(CLANG FALSE)
ENDIF()

IF(CMAKE_C_COMPILER_ID STREQUAL "GNU")
  SET(GCC TRUE)
ELSE()
  SET(GCC FALSE)
ENDIF()

IF(CLANG OR GCC)
  SET(GCC_OR_CLANG TRUE)
ELSE()
  SET(GCC_OR_CLANG FALSE)
ENDIF()

FUNCTION(ADD_CFLAG flag flag_supported)
  CHECK_C_COMPILER_FLAG(${flag} ${flag_supported})
  IF(${flag_supported})
    SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${flag}" PARENT_SCOPE)
  ENDIF()
ENDFUNCTION(ADD_CFLAG flag flag_supported)

CHECK_C_COMPILER_FLAG(-std=c99 C99_FLAG_SUPPORTED)
IF (${C99_FLAG_SUPPORTED})
  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99")
ENDIF()

ADD_CFLAG(-march=native ARCH_NATIVE_FLAG_SUPPORTED)
ADD_CFLAG(-Wextra WARN_EXTRA_FLAG_SUPPORTED)
ADD_CFLAG(-Wall WARN_ALL_FLAG_SUPPORTED)
ADD_CFLAG(-fsigned-char SIGNED-CHAR_FLAG_SUPPORTED)
ADD_CFLAG(-fwrapv WRAPV_FLAG_SUPPORTED)
ADD_CFLAG(-Wconversion CONVERSION_FLAG_SUPPORTED)
ADD_CFLAG(-Wno-sign-conversion NO_SIGN_CONVERSION_FLAG_SUPPORTED)
ADD_CFLAG(-Wmissing-format-attribute MISSING_FORMAT_ATTRIBUTE_FLAG_SUPPORTED)
ADD_CFLAG(-Wpointer-arith POINTER_ARITH_FLAG_SUPPORTED)
# ADD_CFLAG(-Wformat-nonliteral FORMAT_NONLITERAL_FLAG_SUPPORTED)
ADD_CFLAG(-Winit-self INIT_SELF_FLAG_SUPPORTED)
ADD_CFLAG(-Wwrite-strings WRITE_STRINGS_FLAG_SUPPORTED)
ADD_CFLAG(-Wshadow SHADOW_FLAG_SUPPORTED)
ADD_CFLAG(-Wenum-compare ENUM_COMPARE_FLAG_SUPPORTED)
ADD_CFLAG(-Wempty-body EMPTY_BODY_FLAG_SUPPORTED)
ADD_CFLAG(-Wparentheses PARENTHESES_FLAG_SUPPORTED)
ADD_CFLAG(-Wcast-align CAST_ALIGN_FLAG_SUPPORTED)
ADD_CFLAG(-Wstrict-aliasing STRICT_ALIASING_FLAG_SUPPORTED)
ADD_CFLAG(--pedantic-errors PEDANTIC_ERRORS_FLAG_SUPPORTED)

IF(DEBUGGING)
  ADD_CFLAG(-Werror WARNINGS_ARE_ERRORS_FLAG_SUPPORTED)
  ADD_CFLAG(-ftest-coverage TEST_COVERAGE_FLAG_SUPPORTED)
  IF(GCC)
    ADD_CFLAG(-fprofile-arcs PROFILE_ARCS_FLAG_SUPPORTED)
    ADD_CFLAG(-fstack-check STACK_CHECK_FLAG_SUPPORTED)
  ELSEIF(CLANG)
    IF(SANITIZE_ADDRESS)
      ADD_CFLAG(-fsanitize=address ASAN_FLAG_SUPPORTED)
      IF (NOT ASAN_FLAG_SUPPORTED)
        MESSAGE(FATAL_ERROR "Could not enable address sanitizer")
      ENDIF()
    ELSEIF(SANITIZE_UNDEFINED)
      ADD_CFLAG(-fsanitize=undefined USAN_FLAG_SUPPORTED)
      IF (NOT USAN_FLAG_SUPPORTED)
        MESSAGE(FATAL_ERROR "Could not enable undefined behavior  sanitizer")
      ENDIF()
    ENDIF()
  ENDIF()
  ADD_CFLAG(-fstack-protector-all STACK_PROTECTOR_ALL_FLAG_SUPPORTED)
  ADD_CFLAG(-O0 O0_FLAG_SUPPORTED)
ELSE()
  ADD_CFLAG(-O3 O3_FLAG_SUPPORTED)
ENDIF()

IF(CLANG)
  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ferror-limit=0")
ENDIF()

CHECK_SYMBOL_EXISTS(memset_s, string.h HAVE_MEMSET_S)
CHECK_SYMBOL_EXISTS(explicit_bzero string.h strings.h HAVE_EXPLICIT_BZERO)

CHECK_INCLUDE_FILES("asm/byteorder.h" HAVE_ASM_BYTEORDER_H)
CHECK_INCLUDE_FILES("inttypes.h" HAVE_INTTYPES_H)
CHECK_INCLUDE_FILES("stdbool.h" HAVE_STDBOOL_H)
CHECK_INCLUDE_FILES("stdint.h" HAVE_STDINT_H)
CHECK_INCLUDE_FILES("sys/types.h" HAVE_SYS_TYPES_H)
CHECK_INCLUDE_FILES("sys/wait.h" HAVE_SYS_WAIT_H)
CHECK_INCLUDE_FILES("unistd.h" HAVE_UNISTD_H)

CONFIGURE_FILE(
  ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in
  ${CMAKE_CURRENT_BINARY_DIR}/config.h
)

INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR})

INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/src)

FIND_PACKAGE(UTF8PROC REQUIRED)
INCLUDE_DIRECTORIES(${UTF8PROC_INCLUDE_DIR})

FIND_PACKAGE(Iconv REQUIRED)
INCLUDE_DIRECTORIES(${ICONV_INCLUDE_DIR})

FIND_PACKAGE(CMOCKA REQUIRED)
INCLUDE_DIRECTORIES(${CMOCKA_INCLUDE_DIR})

INCLUDE_DIRECTORIES(${CMAKE_BINARY_DIR})

IF(GCC_OR_CLANG)
  ADD_DEFINITIONS(-D_GNU_SOURCE)
ENDIF()

OPTION(CBASE_LOG_DUMP_LOGGING_ERRORS_TO_STDERR "Dump logging errors to STDERR" "hey")
IF (NOT CBASE_LOG_DUMP_LOGGING_ERRORS_TO_STDERR)
  SET(CBASE_LOG_DUMP_LOGGING_ERRORS_TO_STDERR "huh")
ENDIF()

SET(CBASE_DEFAULT_LOG CACHE STRING "Default log")
SET_PROPERTY(CACHE CBASE_DEFAULT_LOG PROPERTY STRINGS "custom" "stderr")

SET(CBASE_DEFAULT_LOG_LEVEL CACHE STRING "Default log's log level")
SET_PROPERTY(CACHE CBASE_DEFAULT_LOG_LEVEL PROPERTY STRINGS
  "CBASE_LOG_LEVEL_DEBUG"
  "CBASE_LOG_LEVEL_INFO"
  "CBASE_LOG_LEVEL_WARNING"
  "CBASE_LOG_LEVEL_FAILURE"
  "CBASE_LOG_LEVEL_ERROR"
  "CBASE_LOG_LEVEL_CRITICAL"
  "CBASE_LOG_LEVEL_FATAL"
  "\"runtime\""
)
IF (CBASE_DEFAULT_LOG_LEVEL AND NOT $CACHE{CBASE_DEFAULT_LOG})
  MESSAGE(
    FATAL_ERROR
    "Cannot set CBASE_DEFAULT_LOG_LEVEL without enabling the default log"
  )
ENDIF()

SET(CBASE_INTERNAL_LOG CACHE STRING "Internal log")
SET_PROPERTY(CACHE CBASE_DEFAULT_LOG PROPERTY STRINGS "default" "custom"
  "stderr")

SET(CBASE_INTERNAL_LOG_LEVEL CACHE STRING "Internal log's log level")
SET_PROPERTY(CACHE CBASE_INTERNAL_LOG_LEVEL PROPERTY STRINGS
  "CBASE_LOG_LEVEL_DEBUG"
  "CBASE_LOG_LEVEL_INFO"
  "CBASE_LOG_LEVEL_WARNING"
  "CBASE_LOG_LEVEL_FAILURE"
  "CBASE_LOG_LEVEL_ERROR"
  "CBASE_LOG_LEVEL_CRITICAL"
  "CBASE_LOG_LEVEL_FATAL"
  "\"runtime\""
)
IF (CBASE_INTERNAL_LOG_LEVEL AND NOT $CACHE{CBASE_INTERNAL_LOG})
  MESSAGE(
    FATAL_ERROR
    "Cannot set CBASE_INTERNAL_LOG_LEVEL without enabling the internal log"
  )
ENDIF()
IF (CBASE_INTERNAL_LOG_LEVEL)
  IF ($CACHE{CBASE_INTERNAL_LOG} STREQUAL "default")
    MESSAGE(
      FATAL_ERROR
      "Cannot set CBASE_INTERNAL_LOG_LEVEL when outputting to the default log"
    )
  ENDIF()
ENDIF()

SET(CBASE_LOG CACHE STRING "Log")
SET_PROPERTY(CACHE CBASE_DEFAULT_LOG PROPERTY STRINGS "default" "custom"
  "stderr")

SET(CBASE_LOG_LEVEL CACHE STRING "Log's log level")
SET_PROPERTY(CACHE CBASE_LOG_LEVEL PROPERTY STRINGS
  "CBASE_LOG_LEVEL_DEBUG"
  "CBASE_LOG_LEVEL_INFO"
  "CBASE_LOG_LEVEL_WARNING"
  "CBASE_LOG_LEVEL_FAILURE"
  "CBASE_LOG_LEVEL_ERROR"
  "CBASE_LOG_LEVEL_CRITICAL"
  "CBASE_LOG_LEVEL_FATAL"
  "\"runtime\""
)
IF (CBASE_LOG_LEVEL AND NOT $CACHE{CBASE_LOG})
  MESSAGE(FATAL_ERROR "Cannot set CBASE_LOG_LEVEL without enabling the log")
ENDIF()
IF (CBASE_LOG_LEVEL)
  IF($CACHE{CBASE_LOG} STREQUAL "default")
    MESSAGE(
      FATAL_ERROR
      "Cannot set CBASE_LOG_LEVEL when outputting to the default log"
    )
  ENDIF()
ENDIF()


SET(FORCE_ENDIANNESS "" CACHE STRING "Force endianness")
SET_PROPERTY(CACHE FORCE_ENDIANNESS PROPERTY STRINGS "big" "little")

IF(${FORCE_ENDIANNESS})
  IF(${FORCE_ENDIANNESS} STREQUAL "big")
    SET(WORDS_BIGENDIAN "on")
  ELSEIF(${FORCE_ENDIANNESS} STREQUAL "little")
    SET(WORDS_LITTLEENDIAN "on")
  ELSE()
    MESSAGE(FATAL_ERROR "Unknown endianness ${FORCE_ENDIANNESS}")
  ENDIF()
ELSE()
  TEST_BIG_ENDIAN(BIGENDIAN)
  IF(${BIGENDIAN})
    SET(WORDS_BIGENDIAN)
  ELSE()
    SET(WORDS_LITTLEENDIAN)
  ENDIF()
ENDIF()

SET(LIBCBASE_SOURCE_FILES
  ${CMAKE_SOURCE_DIR}/src/alloc.c
  ${CMAKE_SOURCE_DIR}/src/array.c
  ${CMAKE_SOURCE_DIR}/src/buffer.c
  ${CMAKE_SOURCE_DIR}/src/charset.c
  ${CMAKE_SOURCE_DIR}/src/errors.c
  ${CMAKE_SOURCE_DIR}/src/file.c
  ${CMAKE_SOURCE_DIR}/src/hash.c
  ${CMAKE_SOURCE_DIR}/src/list.c
  ${CMAKE_SOURCE_DIR}/src/log.c
  ${CMAKE_SOURCE_DIR}/src/rune.c
  ${CMAKE_SOURCE_DIR}/src/slice.c
  ${CMAKE_SOURCE_DIR}/src/sslice.c
  ${CMAKE_SOURCE_DIR}/src/str.c
  ${CMAKE_SOURCE_DIR}/src/strbase.c
  ${CMAKE_SOURCE_DIR}/src/table.c
  ${CMAKE_SOURCE_DIR}/src/utf8.c
  ${CMAKE_SOURCE_DIR}/src/util.c
  ${CMAKE_SOURCE_DIR}/src/xxhash.c
)

SET(INCLUDE_FILES
  ${CMAKE_SOURCE_DIR}/src/cbase/alloc.h
  ${CMAKE_SOURCE_DIR}/src/cbase/array.h
  ${CMAKE_SOURCE_DIR}/src/cbase/buffer.h
  ${CMAKE_SOURCE_DIR}/src/cbase/cbase_log.h
  ${CMAKE_SOURCE_DIR}/src/cbase/charset.h
  ${CMAKE_SOURCE_DIR}/src/cbase/default_log.h
  ${CMAKE_SOURCE_DIR}/src/cbase/errors.h
  ${CMAKE_SOURCE_DIR}/src/cbase/file.h
  ${CMAKE_SOURCE_DIR}/src/cbase/hash.h
  ${CMAKE_SOURCE_DIR}/src/cbase/list.h
  ${CMAKE_SOURCE_DIR}/src/cbase/log.h
  ${CMAKE_SOURCE_DIR}/src/cbase/logbase.h
  ${CMAKE_SOURCE_DIR}/src/cbase/rune.h
  ${CMAKE_SOURCE_DIR}/src/cbase/slice.h
  ${CMAKE_SOURCE_DIR}/src/cbase/sslice.h
  ${CMAKE_SOURCE_DIR}/src/cbase/str.h
  ${CMAKE_SOURCE_DIR}/src/cbase/swap.h
  ${CMAKE_SOURCE_DIR}/src/cbase/table.h
  ${CMAKE_SOURCE_DIR}/src/cbase/types.h
  ${CMAKE_SOURCE_DIR}/src/cbase/utf8.h
  ${CMAKE_SOURCE_DIR}/src/cbase/util.h
  ${CMAKE_SOURCE_DIR}/src/cbase/xxhash.h
  ${CMAKE_SOURCE_DIR}/src/cbase.h
)

SET(LIBCBASE_LIBRARIES
  ${UTF8PROC_LIBRARIES}
  ${ICONV_LIBRARIES}
)

SET(CBASETEST_LIBRARIES ${LIBCBASE_LIBRARIES}
  ${CMOCKA_LIBRARIES}
)

ADD_LIBRARY(cbasestaticlib STATIC ${LIBCBASE_SOURCE_FILES})
TARGET_LINK_LIBRARIES(cbasestaticlib ${LIBCBASE_LIBRARIES})
SET_TARGET_PROPERTIES(cbasestaticlib PROPERTIES OUTPUT_NAME cbase)

ADD_LIBRARY(cbasesharedlib SHARED ${LIBCBASE_SOURCE_FILES})
TARGET_LINK_LIBRARIES(cbasesharedlib ${LIBCBASE_LIBRARIES})
SET_TARGET_PROPERTIES(cbasesharedlib PROPERTIES OUTPUT_NAME cbase)

ADD_EXECUTABLE(cbase_test ${LIBCBASE_SOURCE_FILES}
  ${CMAKE_SOURCE_DIR}/test/alloc.c
  ${CMAKE_SOURCE_DIR}/test/array.c
  ${CMAKE_SOURCE_DIR}/test/charset.c
  ${CMAKE_SOURCE_DIR}/test/dlist.c
  ${CMAKE_SOURCE_DIR}/test/list.c
  ${CMAKE_SOURCE_DIR}/test/main.c
  ${CMAKE_SOURCE_DIR}/test/path.c
  ${CMAKE_SOURCE_DIR}/test/sslice.c
  ${CMAKE_SOURCE_DIR}/test/status.c
  ${CMAKE_SOURCE_DIR}/test/str.c
  ${CMAKE_SOURCE_DIR}/test/table.c
  ${CMAKE_SOURCE_DIR}/test/utf8.c
)
TARGET_LINK_LIBRARIES(cbase_test ${CBASETEST_LIBRARIES})

IF((NOT DEFINED BIN_DIR) OR (BIN_DIR STREQUAL ""))
  SET(BIN_DIR "${PREFIX}/bin")
ENDIF()

IF((NOT DEFINED LIB_DIR) OR (LIB_DIR STREQUAL ""))
  SET(LIB_DIR "${PREFIX}/lib")
ENDIF()

IF((NOT DEFINED INCLUDE_DIR) OR (INCLUDE_DIR STREQUAL ""))
  SET(INCLUDE_DIR "${PREFIX}/include")
ENDIF()

IF((NOT DEFINED SHARE_DIR) OR (SHARE_DIR STREQUAL ""))
  SET(SHARE_DIR "${PREFIX}/share")
ENDIF()

INSTALL(
  TARGETS cbasestaticlib cbasesharedlib
  RUNTIME DESTINATION ${BIN_DIR}
  LIBRARY DESTINATION ${LIB_DIR}
  ARCHIVE DESTINATION ${LIB_DIR}
)

INSTALL(
  FILES ${INCLUDE_FILES}
  DESTINATION ${INCLUDE_DIR}/cbase
)

INSTALL(
  FILES ${CMAKE_SOURCE_DIR}/src/cbase.h
  DESTINATION ${INCLUDE_DIR}
)

# vi: ai:ts=2:sw=2:et