view release on metacpan or  search on metacpan

jq/CMakeLists.txt  view on Meta::CPAN

cmake_minimum_required(VERSION 3.13)
project(jq C)

set(PACKAGE jq)
set(PACKAGE_VERSION "1.6")
set(SO_VERSION "1:4:0")

# interface target holding all compile flags, includes and link dependencies
add_library(jq_compiler_flags INTERFACE)
target_compile_features(jq_compiler_flags INTERFACE c_std_11)
target_compile_options(jq_compiler_flags INTERFACE
  "$<$<COMPILE_LANG_AND_ID:C,GNU>:$<BUILD_INTERFACE:-Wall;-Wextra;-Wno-missing-field-initializers;-Wno-unused-parameter;-Wno-unused-function>>"
  "$<$<COMPILE_LANG_AND_ID:C,MSVC>:$<BUILD_INTERFACE:-W4>>"
)
target_include_directories(jq_compiler_flags INTERFACE
  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
  $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>
)

# control where the static and shared libraries are built so that on windows
# we don't need to tinker with the path to run the executable
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}")
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}")
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}")
#if(APPLE)
#  set(CMAKE_INSTALL_RPATH "@executable_path/../lib")
#elseif(UNIX)
#  set(CMAKE_INSTALL_RPATH "$ORIGIN/../lib")
#endif()

function(target_compile_definitions_if_true)
  foreach(arg IN LISTS ARGN)
    if(${arg})
      #message(STATUS "define ${arg}")
      target_compile_definitions(jq_compiler_flags INTERFACE ${arg}=1)
    endif()
  endforeach()
endfunction()

#option(BUILD_SHARED_LIBS "Build using shared libraries" ON)
#if(MSVC)
#  option(MSVC_STATIC_RUNTIME "Build with static runtime" OFF)
#endif()
option(ENABLE_MAINTAINER_MODE "Enable maintainer mode" ON)
option(ENABLE_VALGRIND "Run tests under Valgrind" ON)
option(ENABLE_ASAN "Enable address sanitizer" OFF)
option(ENABLE_UBSAN "Enable undefined behavior sanitizer" OFF)
option(ENABLE_GCOV "Enable gcov code coverage tool" OFF)
option(ENABLE_DOCS "Build docs" ON)
option(ENABLE_ERROR_INJECTION "Build and test with error injection" OFF)
option(ENABLE_ALL_STATIC "Link jq with static libraries only" OFF)
option(ENABLE_PTHREAD_TLS "Enable use of pthread thread local storage" OFF)
option(WITH_ONIGURUMA "Try this for a non-standard install prefix of the oniguruma library" "yes")

# maintainer mode requires bison and flex
if(ENABLE_MAINTAINER_MODE)
  find_package(BISON 3.0 REQUIRED)
  find_package(FLEX REQUIRED)
endif()

find_program(VALGRIND_cmd valgrind DOC "valgrind is required to test jq")
if(NOT VALGRIND_cmd)
  option(ENABLE_VALGRIND "Run tests under Valgrind" OFF)
endif()

if(ENABLE_DOCS)
  find_program(BUNDLE_cmd bundle DOC "bundle is required to build jq documentation")
  if(NOT BUNDLE_cmd)
    option(ENABLE_DOCS "Build docs" OFF)
    message(WARNING "Ruby dependencies for building jq documentation not found")
  endif()
endif()

set(VERSION ${PACKAGE_VERSION})
target_compile_definitions(jq_compiler_flags INTERFACE PACKAGE=${PACKAGE} VERSION=${VERSION})

include(modules/oniguruma/cmake/dist.cmake)
include(CheckCSourceCompiles)
include(CheckIncludeFiles)
include(CheckFunctionExists)
include(CheckSymbolExists)
include(CheckStructHasMember)
include(TestBigEndian)

jq/CMakeLists.txt  view on Meta::CPAN

  HAVE_Y0
  HAVE_Y1
  HAVE_YN
)

CHECK_C_SOURCE_COMPILES("static __thread int x = 1; int main() { return x; }" HAVE___THREAD)
target_compile_definitions_if_true(HAVE___THREAD)

TEST_BIG_ENDIAN(TEST_BYTE_ORDER_BIG_ENDIAN)
if(TEST_BYTE_ORDER_BIG_ENDIAN)
  target_compile_definitions(jq_compiler_flags INTERFACE IEEE_MC68k=1)
else()
  target_compile_definitions(jq_compiler_flags INTERFACE IEEE_8087=1)
endif()

set(HAVE_LIBONIG 0)
if(WITH_ONIGURUMA STREQUAL "builtin")
  message(STATUS "build and link builtin oniguruma library")
  add_subdirectory(modules/oniguruma)
  set(HAVE_LIBONIG 1)
elseif(IS_DIRECTORY ${WITH_ONIGURUMA})
  message(STATUS "link oniguruma library from ${WITH_ONIGURUMA}")
  find_package(oniguruma REQUIRED PATHS ${WITH_ONIGURUMA} NO_DEFAULT_PATH)
else()
  find_package(oniguruma)
endif()
if(oniguruma_FOUND)
  set(HAVE_LIBONIG 1)
endif()
target_compile_definitions_if_true(HAVE_LIBONIG)

add_library(jq
  src/builtin.c src/bytecode.c src/compile.c src/execute.c
  src/jq_test.c src/jv.c src/jv_alloc.c src/jv_aux.c
  src/jv_dtoa.c src/jv_file.c src/jv_parse.c src/jv_print.c
  src/jv_unicode.c src/linker.c src/locfile.c src/util.c
  src/builtin.h src/bytecode.h src/compile.h
  src/exec_stack.h src/jq_parser.h src/jv_alloc.h src/jv_dtoa.h
  src/jv_unicode.h src/jv_utf8_tables.h src/lexer.l src/libm.h
  src/linker.h src/locfile.h src/opcode_list.h src/parser.y
  src/util.h
)
target_link_libraries(jq PUBLIC "$<BUILD_INTERFACE:jq_compiler_flags>")
target_link_libraries(jq PUBLIC -lm)
target_link_options(jq PRIVATE -export-symbols-regex '^j[qv]_' -version-info ${SO_VERSION})
#target_link_options(jq PRIVATE -export-symbols-regex '^j[qv]_')
set_target_properties(jq PROPERTIES
  VERSION ${VERSION}
  SOVERSION ${SO_VERSION}
)
if(HAVE_WIN32)
  target_link_libraries(jq PUBLIC -lshlwapi)
endif()

if(ENABLE_MAINTAINER_MODE)
  FLEX_TARGET(jq_lexer src/lexer.l ${CMAKE_CURRENT_SOURCE_DIR}/src/lexer.c
    COMPILE_FLAGS --warnings=all -d
    DEFINES_FILE ${CMAKE_CURRENT_SOURCE_DIR}/src/lexer.h
  )
  target_sources(jq PRIVATE
    ${FLEX_JQ_LEXER_OUTPUTS} ${FLEX_JQ_LEXER_OUTPUT_HEADER}
    src/parser.h src/parser.c
    src/builtin.inc src/version.h
  )
else()
  target_sources(jq PRIVATE
    src/lexer.h src/lexer.c
    src/parser.h src/parser.c
    src/builtin.inc src/version.h
  )
endif()

if(ENABLE_UBSAN)
  target_compile_options(jq PUBLIC -fsanitize=undefined)
endif()

if(ENABLE_ASAN)
  target_compile_options(jq PUBLIC -fsanitize=address)
  set(NO_VALGRIND ON)
  if(ENABLE_VALGRIND)
    set(NO_VALGRIND OFF)
  else()
    set(NO_VALGRIND ON)
  endif()
endif()

if(ENABLE_GCOV)
  target_compile_options(jq PUBLIC --coverage --no-inline)
endif()

if(ENABLE_ERROR_INJECTION)
  add_library(jq_inject_errors src/inject_errors.c)
  target_link_libraries(jq_inject_errors PRIVATE dl)
  target_link_options(jq_inject_errors PRIVATE -module)
endif()

# TODO: remake src/version.h if and only if the git ID has changed

add_custom_command(
  OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/src/builtin.inc
  DEPENDS src/builtin.jq
  COMMENT "making src/builtin.inc from src/builtin.jq"
  COMMAND perl ${CMAKE_CURRENT_SOURCE_DIR}/scripts/gen_builtin_inc.pl ${CMAKE_CURRENT_SOURCE_DIR}/src/builtin.jq > ${CMAKE_CURRENT_SOURCE_DIR}/src/builtin.inc
)
set_source_files_properties(src/builtin.c PROPERTIES OBJECT_DEPENDS src/builtin.inc)

if(${WITH_ONIGURUMA} STREQUAL "builtin")
  target_link_libraries(jq PUBLIC onig)
  target_include_directories(jq PUBLIC
  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/modules/oniguruma/src>
  $<INSTALL_INTERFACE:include>
  )
elseif(HAVE_LIBONIG)
  target_link_libraries(jq PUBLIC oniguruma::onig)
endif()

# src/builtin.c calls setenv, which is not portable on windows
# below check will add a local implementation and compile
if(WIN32 AND MINGW)
  check_symbol_exists(setenv  "stdlib.h"  HAVE_SETENV)
  target_compile_definitions_if_true(HAVE_SETENV)
  if(NOT HAVE_SETENV)
    target_sources(jq PRIVATE
      src/setenv.h src/setenv.c
    )
    message(STATUS "patching src/builtin.c")
    execute_process(
      COMMAND patch -p0 -N --binary -i builtin.c.patch
      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
    )
  endif()
endif()

add_executable(jq_bin src/main.c src/version.h)
set_target_properties(jq_bin PROPERTIES OUTPUT_NAME jq)
target_link_libraries(jq_bin PRIVATE jq)

if(ENABLE_ALL_STATIC)
  target_link_options(jq_bin PRIVATE -all-static)
endif()

# TODO: support test and build manpage
if(ENABLE_DOCS)
endif()


# TODO: support full packaging
install_library(jq)
install_executable(jq_bin)
install_header(src/jv.h src/jq.h)
install_data(AUTHORS COPYING NEWS README)

# export cmake configurations
install(TARGETS jq onig EXPORT jqTargets)
install(EXPORT jqTargets FILE jqTargets.cmake DESTINATION lib/cmake/jq)
include(CMakePackageConfigHelpers)
# generate the config file that includes the exports
configure_package_config_file(
  ${CMAKE_CURRENT_SOURCE_DIR}/Config.cmake.in
  ${CMAKE_CURRENT_BINARY_DIR}/jqConfig.cmake
  INSTALL_DESTINATION lib/cmake/jq
  NO_SET_AND_CHECK_MACRO
  NO_CHECK_REQUIRED_COMPONENTS_MACRO
)
# generate the version file for the config file
write_basic_package_version_file(
  ${CMAKE_CURRENT_BINARY_DIR}/jqConfigVersion.cmake
  VERSION ${PACKAGE_VERSION}
  COMPATIBILITY AnyNewerVersion
)
# install the configuration file
install(FILES
  ${CMAKE_CURRENT_BINARY_DIR}/jqConfig.cmake
  ${CMAKE_CURRENT_BINARY_DIR}/jqConfigVersion.cmake
  DESTINATION lib/cmake/jq
)

# information in legacy pkgconfig is wrong/missing
#configure_file(${CMAKE_CURRENT_SOURCE_DIR}/jq.pc.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/jq.pc @ONLY)
#install(FILES ${CMAKE_CURRENT_BINARY_DIR}/jq.pc DESTINATION lib/pkgconfig)

#export(EXPORT jqTargets FILE ${CMAKE_CURRENT_BINARY_DIR}/jqTargets.cmake)