mirror/json-c
1
0
Fork 0
mirror of https://github.com/json-c/json-c.git synced 2026-03-13 18:19:06 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
61016412fbfa03ce116e6e921ee7a1898766b16c
json-c/CMakeLists.txt

573 lines
20 KiB
CMake
Raw Normal View History

Bump up the minimum cmake version to 3.9. This gets us up to a version that supports features we're already using (i.e. add_compile_options), but stops short of a cmake that requires c++11, which some OSes still don't support. Closes issue #774
2023-02-23 01:01:14 +00:00
# CMake 3.9 was released in 2017/07
# As of 2023, many versions of Linux, NetBSD and FreeBSD provide,
# and many OpenWRT packages require, much newer CMake packages.
# We're stopping before 3.10 because that version starts requiring
# c++11, which isn't available on e.g HPUX.
CMake: request all policies up to CMake 3.12 being set to NEW
2023-09-05 14:31:24 +02:00
cmake_minimum_required(VERSION 3.9...3.12)
Add Cmakefile
2016-08-24 00:16:13 -07:00
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
# JSON-C library is C only project.
Bump up the minimum cmake version to 3.9. This gets us up to a version that supports features we're already using (i.e. add_compile_options), but stops short of a cmake that requires c++11, which some OSes still don't support. Closes issue #774
2023-02-23 01:01:14 +00:00
# PROJECT_VERSION{,_MAJOR,_MINOR,_PATCH} set by project():
Update the master branch to version 0.17.99
2023-08-12 19:08:59 +00:00
project(json-c LANGUAGES C VERSION 0.17.99)
Use cmake to create the json-c.pc file, as suggested by PR#362.
2017-10-09 13:16:00 -04:00
modify json-c default build type, and fix up the assert() errors in testcase
2020-02-29 15:32:42 +08:00
# set default build type if not specified by user
if(NOT CMAKE_BUILD_TYPE)
set(CMAKE_BUILD_TYPE debug)
endif()
modify RELEASE
2020-03-03 14:16:13 +08:00
set(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O2")
update testcase and delete debug -O0 build
2020-03-02 20:19:35 +08:00
Build and run the tests as part of the cmake build.
2019-11-23 15:15:48 -05:00
include(CTest)
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
# Set some packaging variables.
set(CPACK_PACKAGE_NAME "${PROJECT_NAME}")
Get the cmake build a bit closer to the autoconf one: include json_visit.h, and fix the version stamped in json-c.pc.
2019-11-23 15:34:23 -05:00
set(CPACK_PACKAGE_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
set(CPACK_PACKAGE_VERSION_MINOR "${PROJECT_VERSION_MINOR}")
set(CPACK_PACKAGE_VERSION_PATCH "${PROJECT_VERSION_PATCH}")
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
set(JSON_C_BUGREPORT "json-c@googlegroups.com")
Increase distcheck target in cmake
2020-02-21 12:16:51 +08:00
set(CPACK_SOURCE_IGNORE_FILES
${PROJECT_SOURCE_DIR}/build
${PROJECT_SOURCE_DIR}/cmake-build-debug
${PROJECT_SOURCE_DIR}/pack
${PROJECT_SOURCE_DIR}/.idea
${PROJECT_SOURCE_DIR}/.DS_Store
${PROJECT_SOURCE_DIR}/.git
${PROJECT_SOURCE_DIR}/.vscode)
Add Cmakefile
2016-08-24 00:16:13 -07:00
Issue #173, follow up to using strtoll to allow this to work on older Windows environments: Use cmake to generate config.h from config.h.win32, including checking for strtoll with cmake, or fall back to _strtoi64 for older MSVC's. Also, add a few missing files to the list of sources to build.
2017-10-03 22:50:29 -04:00
include(CheckSymbolExists)
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
include(CheckIncludeFile)
include(CheckIncludeFiles)
include(CheckCSourceCompiles)
include(CheckTypeSize)
include(CPack)
include(GNUInstallDirs)
include(CMakePackageConfigHelpers)
Switch to building a dynamic lib by default. Tweak language in the README.md slightly. Inspired by PR#452.
2018-12-11 20:59:08 -05:00
option(BUILD_SHARED_LIBS "Default to building shared libraries" ON)
update
2020-05-07 14:50:43 +08:00
option(BUILD_STATIC_LIBS "Default to building static libraries" ON)
Switch to building a dynamic lib by default. Tweak language in the README.md slightly. Inspired by PR#452.
2018-12-11 20:59:08 -05:00
To avoid target exe file export JSON functions.
2021-03-02 14:27:40 +08:00
if (BUILD_SHARED_LIBS)
add_definitions(-D JSON_C_DLL)
endif()
Increase distcheck target in cmake
2020-02-21 12:16:51 +08:00
# Generate a release merge and test it to verify the correctness of republishing the package.
ADD_CUSTOM_TARGET(distcheck
COMMAND make package_source
COMMAND tar -xvf "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source.tar.gz"
COMMAND mkdir "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source/build"
COMMAND cmake "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source/" -B"./${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source/build/"
COMMAND make -C "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source/build"
COMMAND make test -C "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source/build"
COMMAND rm -rf "${PROJECT_NAME}-${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}.${PROJECT_VERSION_PATCH}-Source"
)
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
# Enable or disable features. By default, all features are turned off.
CMake: Re-format config-option block and re-order it alphabetically.
2020-05-18 12:26:47 +02:00
option(DISABLE_BSYMBOLIC "Avoid linking with -Bsymbolic-function." OFF)
option(DISABLE_THREAD_LOCAL_STORAGE "Disable using Thread-Local Storage (HAVE___THREAD)." OFF)
option(DISABLE_WERROR "Avoid treating compiler warnings as fatal errors." OFF)
option(ENABLE_RDRAND "Enable RDRAND Hardware RNG Hash Seed." OFF)
option(ENABLE_THREADING "Enable partial threading support." OFF)
Issue #594 - provide an OVERRIDE_GET_RANDOM_SEED cmake variable to override json_c_get_random_seed() for embedded platforms where time(NULL) doesn't work. Example: mkdir build && cd build cmake -DOVERRIDE_GET_RANDOM_SEED='do { extern uint32_t getMsTicks(void); int ms = getMsTicks() * 433494437; return ms; } while(0)' ..
2020-07-22 02:25:03 +00:00
option(OVERRIDE_GET_RANDOM_SEED "Override json_c_get_random_seed() with custom code." OFF)
Add a DISABLE_EXTRA_LIBS option to skip using libbsd, per @neheb's request on issue #692/commit 0f61f692.
2021-02-15 20:19:56 +00:00
option(DISABLE_EXTRA_LIBS "Avoid linking against extra libraries, such as libbsd." OFF)
json_patch: add first implementation only with patch application Initially I wanted to also do a function that generates the JSON patch from two JSON documents, but even just applying the JSON patch was a bit of work, especially when needing to satisfy all the test-cases. This change defines all the operation in the RFC6902. The addition isn't too big (for the json_patch_apply() function), as part of the heavy lifting is also done by JSON pointer logic. All the ops were tested with the test-cases defined at: https://github.com/json-patch/json-patch-tests RFC6902: https://tools.ietf.org/html/rfc6902 Signed-off-by: Alexandru Ardelean <ardeleanalex@gmail.com>
2021-04-24 17:00:13 +03:00
option(DISABLE_JSON_POINTER "Disable JSON pointer (RFC6901) and JSON patch support." OFF)
option(DISABLE_JSON_PATCH "Disable JSON patch (RFC6902) support." OFF)
Issue #668: add the option to specify "cmake -DUSELOCALE_NEEDS_FREELOCALE=1" to work around a bug in older versions of FreeBSD (<12.4).
2023-07-30 13:38:15 -04:00
option(NEWLOCALE_NEEDS_FREELOCALE "Work around newlocale bugs in old FreeBSD by calling freelocale" OFF)
Added option to disable app build
2023-08-04 19:46:50 +05:00
option(BUILD_APPS "Default to building apps" ON)
Issue #594 - provide an OVERRIDE_GET_RANDOM_SEED cmake variable to override json_c_get_random_seed() for embedded platforms where time(NULL) doesn't work. Example: mkdir build && cd build cmake -DOVERRIDE_GET_RANDOM_SEED='do { extern uint32_t getMsTicks(void); int ms = getMsTicks() * 433494437; return ms; } while(0)' ..
2020-07-22 02:25:03 +00:00
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
if (UNIX OR MINGW OR CYGWIN)
list(APPEND CMAKE_REQUIRED_DEFINITIONS -D_GNU_SOURCE)
endif()
if (UNIX)
list(APPEND CMAKE_REQUIRED_LIBRARIES m)
endif()
if (MSVC)
list(APPEND CMAKE_REQUIRED_DEFINITIONS /D_CRT_SECURE_NO_DEPRECATE)
list(APPEND CMAKE_REQUIRED_FLAGS /wd4996)
endif()
Issue #508: `-fPIC` to link libjson-c.a with libs json-c has symbol collisions with other popular C JSON libraries. To prevent random crashes in downstream applications that may use a library which depends on json-c, the solution is to statically link libjson-c.a into those libraries. `-fPIC`/`-fPIE` is required when building a `.a` so it can be linked into a `.so`.
2020-06-14 12:01:48 -04:00
if (NOT DISABLE_STATIC_FPIC)
# Use '-fPIC'/'-fPIE' option.
# This will allow other libraries to statically link in libjson-c.a
# which in turn prevents crashes in downstream apps that may use
# a different JSON library with identical symbol names.
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
endif()
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
check_include_file("fcntl.h" HAVE_FCNTL_H)
check_include_file("inttypes.h" HAVE_INTTYPES_H)
check_include_file(stdarg.h HAVE_STDARG_H)
check_include_file(strings.h HAVE_STRINGS_H)
check_include_file(string.h HAVE_STRING_H)
check_include_file(syslog.h HAVE_SYSLOG_H)
Add a few missing features to the cmake setup that are present in configure.ac: Include all compiler warnings, and provide DISABLE_WERROR to make them not be errors. Define _REENTRANT, if setting it works. Set -Bsymbolic-functions, and provide DISABLE_BSYMBOLIC to turn that off. Implement the check for HAS_GNU_WARNING_LONG
2019-11-26 23:01:27 -05:00
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
check_include_files("stdlib.h;stdarg.h;string.h;float.h" STDC_HEADERS)
check_include_file(unistd.h HAVE_UNISTD_H)
check_include_file(sys/types.h HAVE_SYS_TYPES_H)
Add an apps directory, and a json_parse program to parse an input file and report on memory usage. This is intended to provide a way, during development, to test out the memory and performance impacts of a change.
2020-04-21 03:51:16 +00:00
check_include_file(sys/resource.h HAVE_SYS_RESOURCE_H) # for getrusage
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
check_include_file("dlfcn.h" HAVE_DLFCN_H)
check_include_file("endian.h" HAVE_ENDIAN_H)
check_include_file("limits.h" HAVE_LIMITS_H)
check_include_file("locale.h" HAVE_LOCALE_H)
check_include_file("memory.h" HAVE_MEMORY_H)
check_include_file(stdint.h HAVE_STDINT_H)
check_include_file(stdlib.h HAVE_STDLIB_H)
check_include_file(sys/cdefs.h HAVE_SYS_CDEFS_H)
check_include_file(sys/param.h HAVE_SYS_PARAM_H)
Use getrandom() if available in json_c_get_random_seed Lower overhead than opening & reading from /dev/urandom, and works in chroots and other situtations where /dev/urandom is not available. Falls back to existing methods when kernel doesn't support the syscall.
2020-07-30 16:13:04 -07:00
check_include_file(sys/random.h HAVE_SYS_RANDOM_H)
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
check_include_file(sys/stat.h HAVE_SYS_STAT_H)
check_include_file(xlocale.h HAVE_XLOCALE_H)
PR #679: add workaround for old compilers w/o stdint.h (i.e. VS2008 and earlier)
2023-08-05 22:11:30 -04:00
# Set json-c specific vars to stamp into json_config.h
# in a way that hopefully won't conflict with other
# projects that use json-c.
If inttypes.h is present, use it, even on Windows.
2021-06-13 21:12:22 +00:00
if (HAVE_INTTYPES_H)
PR #679: add workaround for old compilers w/o stdint.h (i.e. VS2008 and earlier)
2023-08-05 22:11:30 -04:00
set(JSON_C_HAVE_INTTYPES_H 1)
endif()
if (HAVE_STDINT_H)
set(JSON_C_HAVE_STDINT_H 1)
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
endif()
Issue #173, follow up to using strtoll to allow this to work on older Windows environments: Use cmake to generate config.h from config.h.win32, including checking for strtoll with cmake, or fall back to _strtoi64 for older MSVC's. Also, add a few missing files to the list of sources to build.
2017-10-03 22:50:29 -04:00
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
check_symbol_exists(_isnan "float.h" HAVE_DECL__ISNAN)
check_symbol_exists(_finite "float.h" HAVE_DECL__FINITE)
if ((MSVC AND NOT (MSVC_VERSION LESS 1800)) OR MINGW OR CYGWIN OR UNIX)
check_symbol_exists(INFINITY "math.h" HAVE_DECL_INFINITY)
check_symbol_exists(isinf "math.h" HAVE_DECL_ISINF)
check_symbol_exists(isnan "math.h" HAVE_DECL_ISNAN)
check_symbol_exists(nan "math.h" HAVE_DECL_NAN)
endif()
check_symbol_exists(_doprnt "stdio.h" HAVE_DOPRNT)
if (UNIX OR MINGW OR CYGWIN)
check_symbol_exists(snprintf "stdio.h" HAVE_SNPRINTF)
endif()
check_symbol_exists(vasprintf "stdio.h" HAVE_VASPRINTF)
check_symbol_exists(vsnprintf "stdio.h" HAVE_VSNPRINTF)
check_symbol_exists(vprintf "stdio.h" HAVE_VPRINTF)
Iesue #692: use arc4random() if it's available (in libc on BSD systems, and libbsd on Linux).
2021-01-13 01:57:25 +00:00
check_symbol_exists(arc4random "stdlib.h" HAVE_ARC4RANDOM)
Add a DISABLE_EXTRA_LIBS option to skip using libbsd, per @neheb's request on issue #692/commit 0f61f692.
2021-02-15 20:19:56 +00:00
if (NOT HAVE_ARC4RANDOM AND DISABLE_EXTRA_LIBS STREQUAL "OFF")
Iesue #692: use arc4random() if it's available (in libc on BSD systems, and libbsd on Linux).
2021-01-13 01:57:25 +00:00
check_include_file(bsd/stdlib.h HAVE_BSD_STDLIB_H)
if (HAVE_BSD_STDLIB_H)
Specify dependent libraries, including -lbsd, in a more consistent way so linking against a static json-c works better. Related issue #766 Use target_link_libraries, plus fill in Libs.private in json-c.pc so pkg-config --static --libs works appropriately. Also, only link against libbsd when arc4random is actually found there.
2022-05-30 15:30:11 +00:00
list(APPEND CMAKE_REQUIRED_LIBRARIES "bsd")
Iesue #692: use arc4random() if it's available (in libc on BSD systems, and libbsd on Linux).
2021-01-13 01:57:25 +00:00
unset(HAVE_ARC4RANDOM CACHE)
check_symbol_exists(arc4random "bsd/stdlib.h" HAVE_ARC4RANDOM)
Specify dependent libraries, including -lbsd, in a more consistent way so linking against a static json-c works better. Related issue #766 Use target_link_libraries, plus fill in Libs.private in json-c.pc so pkg-config --static --libs works appropriately. Also, only link against libbsd when arc4random is actually found there.
2022-05-30 15:30:11 +00:00
if (NOT HAVE_ARC4RANDOM)
list(REMOVE_ITEM CMAKE_REQUIRED_LIBRARIES "bsd")
endif()
Iesue #692: use arc4random() if it's available (in libc on BSD systems, and libbsd on Linux).
2021-01-13 01:57:25 +00:00
endif()
endif()
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
if (HAVE_FCNTL_H)
check_symbol_exists(open "fcntl.h" HAVE_OPEN)
endif()
if (HAVE_STDLIB_H)
check_symbol_exists(realloc "stdlib.h" HAVE_REALLOC)
endif()
if (HAVE_LOCALE_H)
check_symbol_exists(setlocale "locale.h" HAVE_SETLOCALE)
check_symbol_exists(uselocale "locale.h" HAVE_USELOCALE)
endif()
Issue #705: disable locale handling when building for a uClibc system because its duplocale() function (intentionally) crashes.
2022-07-30 20:27:35 +00:00
# uClibc *intentionally* crashes in duplocale(), at least as of:
# https://github.com/ffainelli/uClibc/blob/266bdc1/libc/misc/locale/locale.c#L1322
[CMP0153](https://cmake.org/cmake/help/latest/policy/CMP0153.html)
2023-12-12 16:28:41 +03:00
# So, if it looks like we're compiling for a system like that just disable
Issue #705: disable locale handling when building for a uClibc system because its duplocale() function (intentionally) crashes.
2022-07-30 20:27:35 +00:00
# locale handling entirely.
Update CMakeLists.txt Replace with `execute_process` available on v3.0+
2023-12-17 11:19:20 +03:00
execute_process (COMMAND ${CMAKE_C_COMPILER} -dumpmachine ERROR_QUIET OUTPUT_VARIABLE CMAKE_GNU_C_MACHINE)
Issue #705: disable locale handling when building for a uClibc system because its duplocale() function (intentionally) crashes.
2022-07-30 20:27:35 +00:00
if (CMAKE_GNU_C_MACHINE MATCHES "uclibc")
message(STATUS "Detected uClibc compiler, disabling locale handling")
set(HAVE_SETLOCALE 0)
set(HAVE_USELOCALE 0)
endif()
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
if (HAVE_STRINGS_H)
check_symbol_exists(strcasecmp "strings.h" HAVE_STRCASECMP)
check_symbol_exists(strncasecmp "strings.h" HAVE_STRNCASECMP)
endif()
if (HAVE_STRING_H)
check_symbol_exists(strdup "string.h" HAVE_STRDUP)
check_symbol_exists(strerror "string.h" HAVE_STRERROR)
endif()
if (HAVE_SYSLOG_H)
check_symbol_exists(vsyslog "syslog.h" HAVE_VSYSLOG)
endif()
Use getrandom() if available in json_c_get_random_seed Lower overhead than opening & reading from /dev/urandom, and works in chroots and other situtations where /dev/urandom is not available. Falls back to existing methods when kernel doesn't support the syscall.
2020-07-30 16:13:04 -07:00
if (HAVE_SYS_RANDOM_H)
check_symbol_exists(getrandom "sys/random.h" HAVE_GETRANDOM)
endif()
Add an apps directory, and a json_parse program to parse an input file and report on memory usage. This is intended to provide a way, during development, to test out the memory and performance impacts of a change.
2020-04-21 03:51:16 +00:00
if (HAVE_SYS_RESOURCE_H)
check_symbol_exists(getrusage "sys/resource.h" HAVE_GETRUSAGE)
endif()
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
Issue #568: fix the strtoll and strtoull handing so config.h ends up creating defines for those only when needed, which should exclude mingw environments.
2020-04-09 20:58:28 +00:00
check_symbol_exists(strtoll "stdlib.h" HAVE_STRTOLL)
check_symbol_exists(strtoull "stdlib.h" HAVE_STRTOULL)
set(json_c_strtoll "strtoll")
if (NOT HAVE_STRTOLL)
# Use _strtoi64 if strtoll is not available.
check_symbol_exists(_strtoi64 "stdlib.h" __have_strtoi64)
if (__have_strtoi64)
#set(HAVE_STRTOLL 1)
set(json_c_strtoll "_strtoi64")
endif()
endif()
set(json_c_strtoull "strtoull")
if (NOT HAVE_STRTOULL)
# Use _strtoui64 if strtoull is not available.
check_symbol_exists(_strtoui64 "stdlib.h" __have_strtoui64)
if (__have_strtoui64)
#set(HAVE_STRTOULL 1)
set(json_c_strtoull "_strtoui64")
endif()
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
endif()
Add a few missing features to the cmake setup that are present in configure.ac: Include all compiler warnings, and provide DISABLE_WERROR to make them not be errors. Define _REENTRANT, if setting it works. Set -Bsymbolic-functions, and provide DISABLE_BSYMBOLIC to turn that off. Implement the check for HAS_GNU_WARNING_LONG
2019-11-26 23:01:27 -05:00
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
check_type_size(int SIZEOF_INT)
check_type_size(int64_t SIZEOF_INT64_T)
check_type_size(long SIZEOF_LONG)
check_type_size("long long" SIZEOF_LONG_LONG)
check_type_size("size_t" SIZEOF_SIZE_T)
Fix typo in previous commit to check for SSIZE_T on MSVC.
2020-06-07 15:19:29 +00:00
if (MSVC)
Change CMakeLists.txt to look for SSIZE_T on MSVC too.
2020-06-07 03:36:59 +00:00
list(APPEND CMAKE_EXTRA_INCLUDE_FILES BaseTsd.h)
Fix typo in previous commit to check for SSIZE_T on MSVC.
2020-06-07 15:19:29 +00:00
check_type_size("SSIZE_T" SIZEOF_SSIZE_T)
Change CMakeLists.txt to look for SSIZE_T on MSVC too.
2020-06-07 03:36:59 +00:00
else()
Kick json_type_string out of struct json_object. The default is now that string data is stored inline at the end of json_object, though to allow for json_object_set_string() to set a _longer_ string, we still need to allow for the possibility of a separate char * pointer. All json types have been split out now, next step it cleanup.
2020-06-07 02:42:58 +00:00
check_type_size("ssize_t" SIZEOF_SSIZE_T)
Change CMakeLists.txt to look for SSIZE_T on MSVC too.
2020-06-07 03:36:59 +00:00
endif()
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
Add a few missing features to the cmake setup that are present in configure.ac: Include all compiler warnings, and provide DISABLE_WERROR to make them not be errors. Define _REENTRANT, if setting it works. Set -Bsymbolic-functions, and provide DISABLE_BSYMBOLIC to turn that off. Implement the check for HAS_GNU_WARNING_LONG
2019-11-26 23:01:27 -05:00
check_c_source_compiles(
Issue #626: Restore compatibility with cmake 2.8 by adjusting quoting and explicitly defining the PROJECT_VERSION* variables.
2020-05-30 19:36:54 +00:00
"
Add a few missing features to the cmake setup that are present in configure.ac: Include all compiler warnings, and provide DISABLE_WERROR to make them not be errors. Define _REENTRANT, if setting it works. Set -Bsymbolic-functions, and provide DISABLE_BSYMBOLIC to turn that off. Implement the check for HAS_GNU_WARNING_LONG
2019-11-26 23:01:27 -05:00
extern void json_object_get();
Issue #626: Restore compatibility with cmake 2.8 by adjusting quoting and explicitly defining the PROJECT_VERSION* variables.
2020-05-30 19:36:54 +00:00
__asm__(\".section .gnu.json_object_get\\n\\t.ascii \\\"Please link against libjson-c instead of libjson\\\"\\n\\t.text\");
Add a few missing features to the cmake setup that are present in configure.ac: Include all compiler warnings, and provide DISABLE_WERROR to make them not be errors. Define _REENTRANT, if setting it works. Set -Bsymbolic-functions, and provide DISABLE_BSYMBOLIC to turn that off. Implement the check for HAS_GNU_WARNING_LONG
2019-11-26 23:01:27 -05:00
int main(int c, char *v) { return 0;}
Issue #626: Restore compatibility with cmake 2.8 by adjusting quoting and explicitly defining the PROJECT_VERSION* variables.
2020-05-30 19:36:54 +00:00
"
Add a few missing features to the cmake setup that are present in configure.ac: Include all compiler warnings, and provide DISABLE_WERROR to make them not be errors. Define _REENTRANT, if setting it works. Set -Bsymbolic-functions, and provide DISABLE_BSYMBOLIC to turn that off. Implement the check for HAS_GNU_WARNING_LONG
2019-11-26 23:01:27 -05:00
HAS_GNU_WARNING_LONG)
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
check_c_source_compiles(
"int main() { int i, x = 0; i = __sync_add_and_fetch(&x,1); return x; }"
HAVE_ATOMIC_BUILTINS)
CMake: Add an option to disable the use of thread-local storage. Using thread-local storage may not be desired in all environments and/or use-cases, thus there should be an option to disable its use on purpose. Fixes #451.
2020-05-18 11:38:58 +02:00
if (NOT DISABLE_THREAD_LOCAL_STORAGE)
check_c_source_compiles(
"__thread int x = 0; int main() { return 0; }"
HAVE___THREAD)
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
CMake: Add an option to disable the use of thread-local storage. Using thread-local storage may not be desired in all environments and/or use-cases, thus there should be an option to disable its use on purpose. Fixes #451.
2020-05-18 11:38:58 +02:00
if (HAVE___THREAD)
set(SPEC___THREAD __thread)
elseif (MSVC)
set(SPEC___THREAD __declspec(thread))
endif()
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
endif()
# Hardware random number is not available on Windows? Says, config.h.win32. Best to preserve compatibility.
if (WIN32)
set(ENABLE_RDRAND 0)
endif()
# Once we've done basic symbol/header searches let's add them in.
Allow use json-c cmake as subproject Now json-c can be bundled to any cmake-based project and used with couple lines of code: add_subdirectory(json-c EXCLUDE_FROM_ALL) target_link_libraries(MyProject json-c)
2018-10-20 10:50:15 +05:00
configure_file(${PROJECT_SOURCE_DIR}/cmake/config.h.in ${PROJECT_BINARY_DIR}/config.h)
CMake: Fix grammar: written -> wrote.
2020-05-18 20:36:05 +02:00
message(STATUS "Wrote ${PROJECT_BINARY_DIR}/config.h")
Allow use json-c cmake as subproject Now json-c can be bundled to any cmake-based project and used with couple lines of code: add_subdirectory(json-c EXCLUDE_FROM_ALL) target_link_libraries(MyProject json-c)
2018-10-20 10:50:15 +05:00
configure_file(${PROJECT_SOURCE_DIR}/cmake/json_config.h.in ${PROJECT_BINARY_DIR}/json_config.h)
CMake: Fix grammar: written -> wrote.
2020-05-18 20:36:05 +02:00
message(STATUS "Wrote ${PROJECT_BINARY_DIR}/json_config.h")
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
fix compilation with clang Fixes the following warning: json_pointer.c:230:7: warning: implicit declaration of function 'vasprintf' is invalid in C99 [-Wimplicit-function-declaration] rc = vasprintf(&path_copy, path_fmt, args);
2020-12-17 19:59:37 -08:00
if ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -ffunction-sections -fdata-sections")
Add a few missing features to the cmake setup that are present in configure.ac: Include all compiler warnings, and provide DISABLE_WERROR to make them not be errors. Define _REENTRANT, if setting it works. Set -Bsymbolic-functions, and provide DISABLE_BSYMBOLIC to turn that off. Implement the check for HAS_GNU_WARNING_LONG
2019-11-26 23:01:27 -05:00
if ("${DISABLE_WERROR}" STREQUAL "OFF")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Werror")
endif()
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wcast-qual")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-error=deprecated-declarations")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wextra")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wwrite-strings")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-unused-parameter")
CMakeLists: do not enforce strict prototypes on Windows. On Windows, or at least when cross-built with Mingw-w64, build fails because strict prototype fails on an included file (thus nothing we can do about in json-c code): > from /home/jehan/dev/src/json-c/json_util.c:44: > /home/jehan/.local/share/crossroad/roads/w64/json-c/include/minwindef.h:196:3: error: function declaration isn't a prototype [-Werror=strict-prototypes] > 196 | typedef INT_PTR (WINAPI *FARPROC) (); > | ^~~~~~~ > /home/jehan/.local/share/crossroad/roads/w64/json-c/include/minwindef.h:197:3: error: function declaration isn't a prototype [-Werror=strict-prototypes] > 197 | typedef INT_PTR (WINAPI *NEARPROC) (); > | ^~~~~~~ > /home/jehan/.local/share/crossroad/roads/w64/json-c/include/minwindef.h:198:3: error: function declaration isn't a prototype [-Werror=strict-prototypes] > 198 | typedef INT_PTR (WINAPI *PROC) (); > | ^~~~~~~ Let's just disable the errors for Windows build.
2020-04-15 13:01:09 +02:00
if (NOT WIN32)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wstrict-prototypes")
endif()
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
add_definitions(-D_GNU_SOURCE)
Issue #808: turn off -Wshorten-64-to-32 for clang builds (aka iOS builds) to workaround "implicit conversion loses integer precision" warnings.
2023-07-30 11:38:01 -04:00
if ("${CMAKE_C_COMPILER_ID}" STREQUAL "Clang")
# Remove this for 1.0 when we can bump the ABI and actually fix these warnings.
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wno-shorten-64-to-32")
endif()
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /DEBUG")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4100")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4996")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4244")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4706")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4702")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4127")
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /wd4701")
endif()
Add Cmakefile
2016-08-24 00:16:13 -07:00
Add a few missing features to the cmake setup that are present in configure.ac: Include all compiler warnings, and provide DISABLE_WERROR to make them not be errors. Define _REENTRANT, if setting it works. Set -Bsymbolic-functions, and provide DISABLE_BSYMBOLIC to turn that off. Implement the check for HAS_GNU_WARNING_LONG
2019-11-26 23:01:27 -05:00
if (NOT ("${CMAKE_C_COMPILER_ID}" STREQUAL "MSVC"))
check_c_source_compiles(
Issue #626: Restore compatibility with cmake 2.8 by adjusting quoting and explicitly defining the PROJECT_VERSION* variables.
2020-05-30 19:36:54 +00:00
"
Add a few missing features to the cmake setup that are present in configure.ac: Include all compiler warnings, and provide DISABLE_WERROR to make them not be errors. Define _REENTRANT, if setting it works. Set -Bsymbolic-functions, and provide DISABLE_BSYMBOLIC to turn that off. Implement the check for HAS_GNU_WARNING_LONG
2019-11-26 23:01:27 -05:00
/* uClibc toolchains without threading barf when _REENTRANT is defined */
#define _REENTRANT 1
#include <sys/types.h>
Fix CMake tests for enforced strict prototypes.
2020-04-14 20:42:32 +02:00
int main (void)
Add a few missing features to the cmake setup that are present in configure.ac: Include all compiler warnings, and provide DISABLE_WERROR to make them not be errors. Define _REENTRANT, if setting it works. Set -Bsymbolic-functions, and provide DISABLE_BSYMBOLIC to turn that off. Implement the check for HAS_GNU_WARNING_LONG
2019-11-26 23:01:27 -05:00
{
return 0;
}
Issue #626: Restore compatibility with cmake 2.8 by adjusting quoting and explicitly defining the PROJECT_VERSION* variables.
2020-05-30 19:36:54 +00:00
"
Add a few missing features to the cmake setup that are present in configure.ac: Include all compiler warnings, and provide DISABLE_WERROR to make them not be errors. Define _REENTRANT, if setting it works. Set -Bsymbolic-functions, and provide DISABLE_BSYMBOLIC to turn that off. Implement the check for HAS_GNU_WARNING_LONG
2019-11-26 23:01:27 -05:00
REENTRANT_WORKS
)
if (REENTRANT_WORKS)
add_compile_options("-D_REENTRANT")
endif()
CMake: Check whether BSYMBOLIC is supported by the linker. Linking with '-Bsymbolic-functions' is supported for ELF-binaries, only.
2020-04-10 14:42:03 +02:00
# OSX Mach-O doesn't support linking with '-Bsymbolic-functions'.
# Others may not support it, too.
list(APPEND CMAKE_REQUIRED_LIBRARIES "-Wl,-Bsymbolic-functions")
check_c_source_compiles(
Issue #626: Restore compatibility with cmake 2.8 by adjusting quoting and explicitly defining the PROJECT_VERSION* variables.
2020-05-30 19:36:54 +00:00
"
Fix CMake tests for enforced strict prototypes.
2020-04-14 20:42:32 +02:00
int main (void)
CMake: Check whether BSYMBOLIC is supported by the linker. Linking with '-Bsymbolic-functions' is supported for ELF-binaries, only.
2020-04-10 14:42:03 +02:00
{
return 0;
}
Issue #626: Restore compatibility with cmake 2.8 by adjusting quoting and explicitly defining the PROJECT_VERSION* variables.
2020-05-30 19:36:54 +00:00
"
CMake: Check whether BSYMBOLIC is supported by the linker. Linking with '-Bsymbolic-functions' is supported for ELF-binaries, only.
2020-04-10 14:42:03 +02:00
BSYMBOLIC_WORKS
)
list(REMOVE_ITEM CMAKE_REQUIRED_LIBRARIES "-Wl,-Bsymbolic-functions")
if (DISABLE_BSYMBOLIC STREQUAL "OFF" AND BSYMBOLIC_WORKS)
CMake: Fix appending of linker flags. There was a typo in `CMAKE_SHARED_LINKER_FLAGS`.
2020-04-10 14:15:52 +02:00
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-Bsymbolic-functions")
Add a few missing features to the cmake setup that are present in configure.ac: Include all compiler warnings, and provide DISABLE_WERROR to make them not be errors. Define _REENTRANT, if setting it works. Set -Bsymbolic-functions, and provide DISABLE_BSYMBOLIC to turn that off. Implement the check for HAS_GNU_WARNING_LONG
2019-11-26 23:01:27 -05:00
# XXX need cmake>=3.13 for this:
#add_link_options("-Wl,-Bsymbolic-functions")
endif()
build: Add symbol versions to all exported symbols With this version script, newly-linked binaries that depend on the json-c shared library will refer to its symbols in a versioned form, preventing their references from being resolved to a symbol of the same name exported by json-glib or libjansson if those libraries appear in dependency search order before json-c, which will usually result in a crash. This is necessary because ELF symbol resolution normally uses a single flat namespace, not a tree like Windows symbol resolution. At least one symbol (json_object_iter_next()) is exported by all three JSON libraries. Linking with -Bsymbolic is not enough to have this effect in all cases, because -Bsymbolic only affects symbol lookup within a shared object, for example when json_object_set_serializer() calls json_object_set_userdata(). It does not affect calls from external code into json-c, unless json-c was statically linked into the external caller. This change will also not prevent code that depends on json-glib or libjansson from finding json-c's symbols and crashing; to prevent that, a corresponding change in json-glib or libjansson would be needed. Adding a symbol-version is a backwards-compatible change, but once added, removing or changing the symbol-version on a symbol would be an incompatible change that requires a SONAME bump. Resolves: https://github.com/json-c/json-c/issues/621 (when combined with an equivalent change to libjansson). Signed-off-by: Simon McVittie <smcv@collabora.com>
2020-06-29 18:16:34 +01:00
file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/check-version-script.sym" "TEST { global: *; };")
list(APPEND CMAKE_REQUIRED_LIBRARIES "-Wl,--version-script,${CMAKE_CURRENT_BINARY_DIR}/check-version-script.sym")
check_c_source_compiles(
"
int main (void)
{
return 0;
}
"
VERSION_SCRIPT_WORKS
)
list(REMOVE_ITEM CMAKE_REQUIRED_LIBRARIES "-Wl,--version-script,${CMAKE_CURRENT_BINARY_DIR}/check-version-script.sym")
if (VERSION_SCRIPT_WORKS)
set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--version-script,${CMAKE_CURRENT_SOURCE_DIR}/json-c.sym")
endif()
Add a few missing features to the cmake setup that are present in configure.ac: Include all compiler warnings, and provide DISABLE_WERROR to make them not be errors. Define _REENTRANT, if setting it works. Set -Bsymbolic-functions, and provide DISABLE_BSYMBOLIC to turn that off. Implement the check for HAS_GNU_WARNING_LONG
2019-11-26 23:01:27 -05:00
endif()
Build and run the tests as part of the cmake build.
2019-11-23 15:15:48 -05:00
if ($ENV{VALGRIND})
# Build so that valgrind doesn't complain about linkhash.c
add_definitions(-DVALGRIND=1)
endif()
Split the list of cmake headers into public and private ones, and only install the public ones.
2017-09-17 21:27:07 -04:00
set(JSON_C_PUBLIC_HEADERS
Issue #585: don't install config.h
2020-04-21 01:13:21 +00:00
# Note: config.h is _not_ included here
Allow use json-c cmake as subproject Now json-c can be bundled to any cmake-based project and used with couple lines of code: add_subdirectory(json-c EXCLUDE_FROM_ALL) target_link_libraries(MyProject json-c)
2018-10-20 10:50:15 +05:00
${PROJECT_BINARY_DIR}/json_config.h
json_pointer: allow the feature to be disabled Some users may not want to included it in their build/system. So allow a cmake symbol to disable it. A user can do 'cmake -DDISABLE_JSON_POINTER=ON <json_c_root_dir>' and disable the json_pointer functionality. That saves about 17 KB (on an x86_64) machine. This may be useful on smaller embedded systems; even though the saving would be fewer kilobytes. One thing that also needs to change a bit, is that the 'json.h' be autogenerated via cmake, in order to conditionally include that "json_pointer.h" file. Signed-off-by: Alexandru Ardelean <ardeleanalex@gmail.com>
2021-04-16 09:42:07 +03:00
${PROJECT_BINARY_DIR}/json.h
Allow use json-c cmake as subproject Now json-c can be bundled to any cmake-based project and used with couple lines of code: add_subdirectory(json-c EXCLUDE_FROM_ALL) target_link_libraries(MyProject json-c)
2018-10-20 10:50:15 +05:00
${PROJECT_SOURCE_DIR}/arraylist.h
${PROJECT_SOURCE_DIR}/debug.h
${PROJECT_SOURCE_DIR}/json_c_version.h
${PROJECT_SOURCE_DIR}/json_inttypes.h
${PROJECT_SOURCE_DIR}/json_object.h
${PROJECT_SOURCE_DIR}/json_object_iterator.h
${PROJECT_SOURCE_DIR}/json_tokener.h
Add includes and split off json_types.h to help ensure that headers can be included in any order.
2020-04-06 13:55:27 +00:00
${PROJECT_SOURCE_DIR}/json_types.h
Allow use json-c cmake as subproject Now json-c can be bundled to any cmake-based project and used with couple lines of code: add_subdirectory(json-c EXCLUDE_FROM_ALL) target_link_libraries(MyProject json-c)
2018-10-20 10:50:15 +05:00
${PROJECT_SOURCE_DIR}/json_util.h
Get the cmake build a bit closer to the autoconf one: include json_visit.h, and fix the version stamped in json-c.pc.
2019-11-23 15:34:23 -05:00
${PROJECT_SOURCE_DIR}/json_visit.h
Allow use json-c cmake as subproject Now json-c can be bundled to any cmake-based project and used with couple lines of code: add_subdirectory(json-c EXCLUDE_FROM_ALL) target_link_libraries(MyProject json-c)
2018-10-20 10:50:15 +05:00
${PROJECT_SOURCE_DIR}/linkhash.h
${PROJECT_SOURCE_DIR}/printbuf.h
Split the list of cmake headers into public and private ones, and only install the public ones.
2017-09-17 21:27:07 -04:00
)
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
Split the list of cmake headers into public and private ones, and only install the public ones.
2017-09-17 21:27:07 -04:00
set(JSON_C_HEADERS
${JSON_C_PUBLIC_HEADERS}
Allow use json-c cmake as subproject Now json-c can be bundled to any cmake-based project and used with couple lines of code: add_subdirectory(json-c EXCLUDE_FROM_ALL) target_link_libraries(MyProject json-c)
2018-10-20 10:50:15 +05:00
${PROJECT_SOURCE_DIR}/json_object_private.h
Create a json_pointer_private.h and move a few things there, fix test warnings, note array_list_insert_idx is private.
2023-07-16 10:48:20 -04:00
${PROJECT_SOURCE_DIR}/json_pointer_private.h
Allow use json-c cmake as subproject Now json-c can be bundled to any cmake-based project and used with couple lines of code: add_subdirectory(json-c EXCLUDE_FROM_ALL) target_link_libraries(MyProject json-c)
2018-10-20 10:50:15 +05:00
${PROJECT_SOURCE_DIR}/random_seed.h
${PROJECT_SOURCE_DIR}/strerror_override.h
${PROJECT_SOURCE_DIR}/math_compat.h
${PROJECT_SOURCE_DIR}/snprintf_compat.h
${PROJECT_SOURCE_DIR}/strdup_compat.h
${PROJECT_SOURCE_DIR}/vasprintf_compat.h
Add Cmakefile
2016-08-24 00:16:13 -07:00
)
set(JSON_C_SOURCES
Allow use json-c cmake as subproject Now json-c can be bundled to any cmake-based project and used with couple lines of code: add_subdirectory(json-c EXCLUDE_FROM_ALL) target_link_libraries(MyProject json-c)
2018-10-20 10:50:15 +05:00
${PROJECT_SOURCE_DIR}/arraylist.c
${PROJECT_SOURCE_DIR}/debug.c
${PROJECT_SOURCE_DIR}/json_c_version.c
${PROJECT_SOURCE_DIR}/json_object.c
${PROJECT_SOURCE_DIR}/json_object_iterator.c
${PROJECT_SOURCE_DIR}/json_tokener.c
${PROJECT_SOURCE_DIR}/json_util.c
${PROJECT_SOURCE_DIR}/json_visit.c
${PROJECT_SOURCE_DIR}/linkhash.c
${PROJECT_SOURCE_DIR}/printbuf.c
${PROJECT_SOURCE_DIR}/random_seed.c
${PROJECT_SOURCE_DIR}/strerror_override.c
Add Cmakefile
2016-08-24 00:16:13 -07:00
)
json_pointer: allow the feature to be disabled Some users may not want to included it in their build/system. So allow a cmake symbol to disable it. A user can do 'cmake -DDISABLE_JSON_POINTER=ON <json_c_root_dir>' and disable the json_pointer functionality. That saves about 17 KB (on an x86_64) machine. This may be useful on smaller embedded systems; even though the saving would be fewer kilobytes. One thing that also needs to change a bit, is that the 'json.h' be autogenerated via cmake, in order to conditionally include that "json_pointer.h" file. Signed-off-by: Alexandru Ardelean <ardeleanalex@gmail.com>
2021-04-16 09:42:07 +03:00
if (NOT DISABLE_JSON_POINTER)
set(JSON_C_PUBLIC_HEADERS ${JSON_C_PUBLIC_HEADERS} ${PROJECT_SOURCE_DIR}/json_pointer.h)
set(JSON_C_SOURCES ${JSON_C_SOURCES} ${PROJECT_SOURCE_DIR}/json_pointer.c)
set(JSON_H_JSON_POINTER "#include \"json_pointer.h\"")
json_patch: add first implementation only with patch application Initially I wanted to also do a function that generates the JSON patch from two JSON documents, but even just applying the JSON patch was a bit of work, especially when needing to satisfy all the test-cases. This change defines all the operation in the RFC6902. The addition isn't too big (for the json_patch_apply() function), as part of the heavy lifting is also done by JSON pointer logic. All the ops were tested with the test-cases defined at: https://github.com/json-patch/json-patch-tests RFC6902: https://tools.ietf.org/html/rfc6902 Signed-off-by: Alexandru Ardelean <ardeleanalex@gmail.com>
2021-04-24 17:00:13 +03:00
if (NOT DISABLE_JSON_PATCH)
set(JSON_C_PUBLIC_HEADERS ${JSON_C_PUBLIC_HEADERS} ${PROJECT_SOURCE_DIR}/json_patch.h)
set(JSON_C_SOURCES ${JSON_C_SOURCES} ${PROJECT_SOURCE_DIR}/json_patch.c)
set(JSON_H_JSON_PATCH "#include \"json_patch.h\"")
endif()
json_pointer: allow the feature to be disabled Some users may not want to included it in their build/system. So allow a cmake symbol to disable it. A user can do 'cmake -DDISABLE_JSON_POINTER=ON <json_c_root_dir>' and disable the json_pointer functionality. That saves about 17 KB (on an x86_64) machine. This may be useful on smaller embedded systems; even though the saving would be fewer kilobytes. One thing that also needs to change a bit, is that the 'json.h' be autogenerated via cmake, in order to conditionally include that "json_pointer.h" file. Signed-off-by: Alexandru Ardelean <ardeleanalex@gmail.com>
2021-04-16 09:42:07 +03:00
else()
set(JSON_H_JSON_POINTER "")
json_patch: add first implementation only with patch application Initially I wanted to also do a function that generates the JSON patch from two JSON documents, but even just applying the JSON patch was a bit of work, especially when needing to satisfy all the test-cases. This change defines all the operation in the RFC6902. The addition isn't too big (for the json_patch_apply() function), as part of the heavy lifting is also done by JSON pointer logic. All the ops were tested with the test-cases defined at: https://github.com/json-patch/json-patch-tests RFC6902: https://tools.ietf.org/html/rfc6902 Signed-off-by: Alexandru Ardelean <ardeleanalex@gmail.com>
2021-04-24 17:00:13 +03:00
set(JSON_H_JSON_PATCH "")
json_pointer: allow the feature to be disabled Some users may not want to included it in their build/system. So allow a cmake symbol to disable it. A user can do 'cmake -DDISABLE_JSON_POINTER=ON <json_c_root_dir>' and disable the json_pointer functionality. That saves about 17 KB (on an x86_64) machine. This may be useful on smaller embedded systems; even though the saving would be fewer kilobytes. One thing that also needs to change a bit, is that the 'json.h' be autogenerated via cmake, in order to conditionally include that "json_pointer.h" file. Signed-off-by: Alexandru Ardelean <ardeleanalex@gmail.com>
2021-04-16 09:42:07 +03:00
endif()
configure_file(json.h.cmakein ${PROJECT_BINARY_DIR}/json.h @ONLY)
Allow use json-c cmake as subproject Now json-c can be bundled to any cmake-based project and used with couple lines of code: add_subdirectory(json-c EXCLUDE_FROM_ALL) target_link_libraries(MyProject json-c)
2018-10-20 10:50:15 +05:00
include_directories(${PROJECT_SOURCE_DIR})
include_directories(${PROJECT_BINARY_DIR})
build,cmake: generate both static and shared libjson Signed-off-by: Alexandru Ardelean <ardeleanalex@gmail.com>
2017-05-03 11:59:31 +03:00
doc: Move Doxyfile into doc subdir
2020-05-18 20:32:35 +02:00
add_subdirectory(doc)
add doc target on cmake
2020-02-26 15:39:27 +08:00
Setted cmake "uninstall" target to exist in unix like operating systems only
2021-07-26 18:52:29 +03:00
# "uninstall" custom target for make generators in unix like operating systems
# and if that target is not present
if (CMAKE_GENERATOR STREQUAL "Unix Makefiles")
if(NOT TARGET uninstall)
add_custom_target(uninstall
COMMAND cat ${PROJECT_BINARY_DIR}/install_manifest.txt | xargs rm
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
)
endif()
Only define an "uninstall" target if it's not already defined (e.g. by projects that include json-c)
2021-07-25 15:11:11 +00:00
endif()
Add uninstall target in cmake
2020-02-27 16:00:09 +08:00
Build and run the tests as part of the cmake build.
2019-11-23 15:15:48 -05:00
# XXX for a normal full distribution we'll need to figure out
# XXX how to build both shared and static libraries.
# Probably leverage that to build a local VALGRIND=1 library for testing too.
The real CMake support This patch provides a CMakeLists.txt file to build JSON-C library without relying on auto-tools support. This makes the build a bit more portable and cleaner. It can detect headers and symbols and generate config.h header file based on those detections. It cannot yet handle ctest(1) as the testing itself depends on comparing the output against files. Testing would need some creative abuse of CMake :) This will be provided a few patches later and may possibly involve refactoring test cases. The patch has been tested on GCC 4.8.5 (Linux), GCC 7.2.0 (MinGW) and Microsoft Visual C++ 16.0 (2010?) locally. Also, compiles correctly on Travis CI and AppVeyor without errors.
2018-07-24 08:06:13 +10:00
add_library(${PROJECT_NAME}
Add Cmakefile
2016-08-24 00:16:13 -07:00
${JSON_C_SOURCES}
${JSON_C_HEADERS}
Modified CMakeLists.txt to use autotools to generate configuration for Unix systems
2016-09-25 22:03:56 -04:00
)
Set the soversion in the cmake built library, and arrange for the file name to be generated appropriately too.
2019-11-25 23:26:48 -05:00
set_target_properties(${PROJECT_NAME} PROPERTIES
Update the master branch to version 0.17.99
2023-08-12 19:08:59 +00:00
VERSION 5.3.0
Update the master branch to version 0.0.14.99
2020-04-19 03:57:08 +00:00
SOVERSION 5)
cmake: add list for build targets
2020-05-08 02:16:52 +03:00
list(APPEND CMAKE_TARGETS ${PROJECT_NAME})
Allow use json-c cmake as subproject Now json-c can be bundled to any cmake-based project and used with couple lines of code: add_subdirectory(json-c EXCLUDE_FROM_ALL) target_link_libraries(MyProject json-c)
2018-10-20 10:50:15 +05:00
# If json-c is used as subroject it set to target correct interface -I flags and allow
# to build external target without extra include_directories(...)
Install CMake module files
2019-05-18 19:44:29 +08:00
target_include_directories(${PROJECT_NAME}
PUBLIC
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>
Allow use json-c cmake as subproject Now json-c can be bundled to any cmake-based project and used with couple lines of code: add_subdirectory(json-c EXCLUDE_FROM_ALL) target_link_libraries(MyProject json-c)
2018-10-20 10:50:15 +05:00
)
Specify dependent libraries, including -lbsd, in a more consistent way so linking against a static json-c works better. Related issue #766 Use target_link_libraries, plus fill in Libs.private in json-c.pc so pkg-config --static --libs works appropriately. Also, only link against libbsd when arc4random is actually found there.
2022-05-30 15:30:11 +00:00
target_link_libraries(${PROJECT_NAME} PUBLIC ${CMAKE_REQUIRED_LIBRARIES})
support to build both static and shared libraries
2020-05-06 10:48:53 +08:00
# Allow to build static and shared libraries at the same time
Issue #598: avoid building static libraries twice.
2020-05-10 03:48:45 +00:00
if (BUILD_STATIC_LIBS AND BUILD_SHARED_LIBS)
cmake: change variable name
2020-05-08 02:19:38 +03:00
set(STATIC_LIB ${PROJECT_NAME}-static)
add_library(${STATIC_LIB} STATIC
support to build both static and shared libraries
2020-05-06 10:48:53 +08:00
${JSON_C_SOURCES}
${JSON_C_HEADERS}
)
Add target include dirs for static library as well
2021-11-10 16:04:01 +01:00
target_include_directories(${PROJECT_NAME}-static
PUBLIC
$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}>
$<BUILD_INTERFACE:${PROJECT_BINARY_DIR}>
)
support to build both static and shared libraries
2020-05-06 10:48:53 +08:00
Specify dependent libraries, including -lbsd, in a more consistent way so linking against a static json-c works better. Related issue #766 Use target_link_libraries, plus fill in Libs.private in json-c.pc so pkg-config --static --libs works appropriately. Also, only link against libbsd when arc4random is actually found there.
2022-05-30 15:30:11 +00:00
target_link_libraries(${PROJECT_NAME}-static PUBLIC ${CMAKE_REQUIRED_LIBRARIES})
support to build both static and shared libraries
2020-05-06 10:48:53 +08:00
# rename the static library
Issue #600: don't rename the static library on Windows, it _needs_ to have a different name because the dll build also creates a "json-c.lib" file.
2020-05-10 03:58:51 +00:00
if (NOT MSVC)
cmake: change variable name
2020-05-08 02:19:38 +03:00
set_target_properties(${STATIC_LIB} PROPERTIES
support to build both static and shared libraries
2020-05-06 10:48:53 +08:00
OUTPUT_NAME ${PROJECT_NAME}
)
Issue #600: don't rename the static library on Windows, it _needs_ to have a different name because the dll build also creates a "json-c.lib" file.
2020-05-10 03:58:51 +00:00
endif()
cmake: add list for build targets
2020-05-08 02:16:52 +03:00
list(APPEND CMAKE_TARGETS ${STATIC_LIB})
support to build both static and shared libraries
2020-05-06 10:48:53 +08:00
endif ()
Issue #471: always create directories with mode 0755, regardless of umask.
2020-04-21 03:19:17 +00:00
# Always create new install dirs with 0755 permissions, regardless of umask
set(CMAKE_INSTALL_DEFAULT_DIRECTORY_PERMISSIONS
OWNER_READ
OWNER_WRITE
OWNER_EXECUTE
GROUP_READ
GROUP_EXECUTE
WORLD_READ
WORLD_EXECUTE
)
cmake: add list for build targets
2020-05-08 02:16:52 +03:00
install(TARGETS ${CMAKE_TARGETS}
Install CMake module files
2019-05-18 19:44:29 +08:00
EXPORT ${PROJECT_NAME}-targets
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
Cause the cmake include dirs to also have ${CMAKE_INSTALL_INCLUDEDIR}/json-c, so downstream packages that use cmake to link against json-c can choose whether to include headers as just e.g. #include <json_object.h>, if they care to do so. Update the README to better explain this, and make a few other tweaks.
2021-12-22 02:52:37 +00:00
INCLUDES DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} ${CMAKE_INSTALL_INCLUDEDIR}/json-c
Install CMake module files
2019-05-18 19:44:29 +08:00
)
install(EXPORT ${PROJECT_NAME}-targets
FILE ${PROJECT_NAME}-targets.cmake
NAMESPACE ${PROJECT_NAME}::
DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
)
configure_package_config_file(
"cmake/Config.cmake.in"
${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config.cmake
INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}"
)
install(
FILES ${PROJECT_BINARY_DIR}/${PROJECT_NAME}-config.cmake
DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/${PROJECT_NAME}
Modified CMakeLists.txt to use autotools to generate configuration for Unix systems
2016-09-25 22:03:56 -04:00
)
Added install instructions for CMake
2016-09-25 14:42:14 -04:00
Re-add creation and installation of the json-c.pc file to the cmake build.
2018-09-01 15:06:14 -04:00
if (UNIX OR MINGW OR CYGWIN)
Installation directories empty with CMake in pkg-config. CMake was not properly substituting the installation dir variables (they ended up all empty), so the pkg-config results were also wrongs. For instance cflags was: -I -I/json-c Even though json-c was found at configure time, this obviously broke the build of any application using it.
2019-01-26 12:30:40 +01:00
SET(prefix ${CMAKE_INSTALL_PREFIX})
# exec_prefix is prefix by default and CMake does not have the
# concept.
SET(exec_prefix ${CMAKE_INSTALL_PREFIX})
SET(libdir ${CMAKE_INSTALL_FULL_LIBDIR})
SET(includedir ${CMAKE_INSTALL_FULL_INCLUDEDIR})
Get the cmake build a bit closer to the autoconf one: include json_visit.h, and fix the version stamped in json-c.pc.
2019-11-23 15:34:23 -05:00
SET(VERSION ${PROJECT_VERSION})
Specify dependent libraries, including -lbsd, in a more consistent way so linking against a static json-c works better. Related issue #766 Use target_link_libraries, plus fill in Libs.private in json-c.pc so pkg-config --static --libs works appropriately. Also, only link against libbsd when arc4random is actually found there.
2022-05-30 15:30:11 +00:00
# Linking against the static json-c requires
# dependent packages to include additional libs:
SET(LIBS_LIST ${CMAKE_REQUIRED_LIBRARIES})
Fix issue #775 - use a loop instead of list(TRANSFORM ...) to support cmake < 3.12.
2022-06-27 02:15:24 +00:00
# Note: We would need cmake >= 3.12 in order to use list(TRANSFORM ...)
function(list_transform_prepend var prefix)
set(temp "")
foreach(f ${${var}})
list(APPEND temp "${prefix}${f}")
endforeach()
set(${var} "${temp}" PARENT_SCOPE)
endfunction()
list_transform_prepend(LIBS_LIST "-l")
Specify dependent libraries, including -lbsd, in a more consistent way so linking against a static json-c works better. Related issue #766 Use target_link_libraries, plus fill in Libs.private in json-c.pc so pkg-config --static --libs works appropriately. Also, only link against libbsd when arc4random is actually found there.
2022-05-30 15:30:11 +00:00
string(REPLACE ";" " " LIBS "${LIBS_LIST}")
Allow use json-c cmake as subproject Now json-c can be bundled to any cmake-based project and used with couple lines of code: add_subdirectory(json-c EXCLUDE_FROM_ALL) target_link_libraries(MyProject json-c)
2018-10-20 10:50:15 +05:00
configure_file(json-c.pc.in json-c.pc @ONLY)
CMake: Install pkgconfig file in proper location by default The default location for pkconfig files on most systems is: ${CMAKE_INSTALL_LIBDIR}/pkgconfig Thus the file should get installed in there by default.
2020-04-12 19:21:54 +02:00
set(INSTALL_PKGCONFIG_DIR "${CMAKE_INSTALL_LIBDIR}/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files")
Allow use json-c cmake as subproject Now json-c can be bundled to any cmake-based project and used with couple lines of code: add_subdirectory(json-c EXCLUDE_FROM_ALL) target_link_libraries(MyProject json-c)
2018-10-20 10:50:15 +05:00
install(FILES ${PROJECT_BINARY_DIR}/json-c.pc DESTINATION "${INSTALL_PKGCONFIG_DIR}")
Re-add creation and installation of the json-c.pc file to the cmake build.
2018-09-01 15:06:14 -04:00
endif ()
* don't assume includedir This change syncs the public header include install location with what gets written into pkgconfig file.
2021-10-15 11:12:39 +02:00
install(FILES ${JSON_C_PUBLIC_HEADERS} DESTINATION ${CMAKE_INSTALL_FULL_INCLUDEDIR}/json-c)
Include the tests and apps directories at the _end_, since order in the cmake rules matters, and fix compile warnings now that we're building those sources with all the regular flags.
2022-05-30 14:33:16 +00:00
if (CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND BUILD_TESTING AND
(NOT MSVC OR NOT (MSVC_VERSION LESS 1800)) # Tests need at least VS2013
)
add_subdirectory(tests)
endif()
Added option to disable app build
2023-08-04 19:46:50 +05:00
if (CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND BUILD_APPS)
Skip apps when we're included in someone else's build. Inspired by ssrlive in PR #813.
2023-07-06 20:56:49 -04:00
# skip apps when we're included in someone else's build
Include the tests and apps directories at the _end_, since order in the cmake rules matters, and fix compile warnings now that we're building those sources with all the regular flags.
2022-05-30 14:33:16 +00:00
if (NOT MSVC) # cmd line apps don't built on Windows currently.
add_subdirectory(apps)
endif()
Skip apps when we're included in someone else's build. Inspired by ssrlive in PR #813.
2023-07-06 20:56:49 -04:00
endif()
Reference in New Issue Copy Permalink