cmake_minimum_required(VERSION 3.14)

# Build performance optimizations

set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE BOOL "Export compile commands for faster IDE integration")

set_property(GLOBAL PROPERTY USE_FOLDERS ON)

# Enable parallel compilation on MSVC

if(MSVC)

add_compile_options(/MP)

endif()

project(

simdjson

# The version number is modified by tools/release.py

VERSION 4.6.1

DESCRIPTION "Parsing gigabytes of JSON per second"

HOMEPAGE_URL "https://simdjson.org/"

LANGUAGES CXX C

)

set(SIMDJSON_GITHUB_REPOSITORY "https://github.com/simdjson/simdjson")

string(

COMPARE EQUAL

"${CMAKE_SOURCE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}"

is_top_project

)

# ---- Options, variables ----

# These version numbers are modified by tools/release.py

set(SIMDJSON_LIB_VERSION "33.0.0" CACHE STRING "simdjson library version")

set(SIMDJSON_LIB_SOVERSION "33" CACHE STRING "simdjson library soversion")

option(SIMDJSON_BUILD_STATIC_LIB "Build simdjson_static library along with simdjson (only makes sense if BUILD_SHARED_LIBS=ON)" OFF)

if(SIMDJSON_BUILD_STATIC_LIB AND NOT BUILD_SHARED_LIBS)

message(WARNING "SIMDJSON_BUILD_STATIC_LIB only makes sense if BUILD_SHARED_LIBS is set to ON")

message(WARNING "You might be building and installing a two identical static libraries.")

endif()

option(SIMDJSON_ENABLE_THREADS "Link with thread support" ON)

include(cmake/simdjson-props.cmake)

include(cmake/implementation-flags.cmake)

include(cmake/exception-flags.cmake)

option(SIMDJSON_DISABLE_DEPRECATED_API "Disables deprecated APIs" OFF)

if(SIMDJSON_DISABLE_DEPRECATED_API)

simdjson_add_props(

target_compile_definitions PUBLIC

SIMDJSON_DISABLE_DEPRECATED_API=1

)

endif()

if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.25.0")

option(SIMDJSON_STATIC_REFLECTION "Enables static reflection (experimental), requires C++26" OFF)

else()

set(SIMDJSON_STATIC_REFLECTION OFF CACHE BOOL "Enables static reflection (experimental)" FORCE)

message(WARNING "SIMDJSON_STATIC_REFLECTION is disabled because your CMake version is below 3.25")

endif()

if(SIMDJSON_STATIC_REFLECTION)

simdjson_add_props(

target_compile_definitions PUBLIC

SIMDJSON_STATIC_REFLECTION=1

)

endif()

option(SIMDJSON_DEVELOPMENT_CHECKS "Enable development-time aids, such as \

checks for incorrect API usage. Enabled by default in DEBUG." OFF)

if(SIMDJSON_DEVELOPMENT_CHECKS)

simdjson_add_props(

target_compile_definitions PUBLIC

SIMDJSON_DEVELOPMENT_CHECKS

)

endif()

# padded_memory_map is always available on POSIX. On Windows it is disabled

# by default because it depends on the `CreateFileMapping2` / `MapViewOfFile3`

# APIs, which require Windows 10 version 1803 or later and are exported via

# onecore.lib rather than the default kernel32.lib. Turn this option ON to

# opt into the feature on Windows; simdjson will then set the appropriate

# Windows version macros and link onecore, so everything that links

# simdjson picks up both the compile-time declarations and the import

# library automatically. The option is a no-op on POSIX (where the feature

# is unconditionally enabled).

option(SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS

"Enable simdjson::padded_memory_map on Windows (requires Windows 10 \

version 1803 or later). Always enabled on POSIX." OFF)

if(SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS)

simdjson_add_props(

target_compile_definitions PUBLIC

SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS=1

)

if(WIN32)

# Raise the Windows version floor so that <windows.h> declares the

# modern memory-mapping APIs, and link the import library that

# actually exports them. _WIN32_WINNT / WINVER / NTDDI_VERSION together

# tell <sdkddkver.h> which APIs to light up.

simdjson_add_props(

target_compile_definitions PUBLIC

_WIN32_WINNT=0x0A00

WINVER=0x0A00

NTDDI_VERSION=0x0A000006 # NTDDI_WIN10_RS5, Windows 10 version 1809

)

simdjson_add_props(

target_link_libraries PUBLIC

onecore

)

endif()

endif()

if(is_top_project)

option(SIMDJSON_INSTALL "Enable target install" ON)

option(SIMDJSON_DEVELOPER_MODE "Enable targets for developing simdjson" OFF)

option(BUILD_SHARED_LIBS "Build simdjson as a shared library" OFF)

option(SIMDJSON_SINGLEHEADER "Disable singleheader generation" ON)

else()

option(SIMDJSON_INSTALL "Enable target install" ${BUILD_SHARED_LIBS})

endif()

include(cmake/handle-deprecations.cmake)

include(cmake/developer-options.cmake)

# ---- simdjson library ----

set(SIMDJSON_SOURCES src/simdjson.cpp)

add_library(simdjson ${SIMDJSON_SOURCES})

add_library(simdjson::simdjson ALIAS simdjson)

set(SIMDJSON_LIBRARIES simdjson)

# Check for <bit> header compatibility

include(CheckIncludeFileCXX)

check_include_file_cxx(bit SIMDJSON_HAS_BIT_HEADER)

# Enable precompiled headers for faster builds

if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.16")

set(SIMDJSON_PRECOMPILE_HEADERS

<algorithm>

<array>

<atomic>

<cassert>

<cctype>

<cerrno>

<cstddef>

<cstdint>

<cstdlib>

<cstring>

<memory>

<string>

<utility>

<vector>

)

if(SIMDJSON_HAS_BIT_HEADER)

list(APPEND SIMDJSON_PRECOMPILE_HEADERS <bit>)

endif()

target_precompile_headers(simdjson PRIVATE ${SIMDJSON_PRECOMPILE_HEADERS})

endif()

if(SIMDJSON_BUILD_STATIC_LIB)

add_library(simdjson_static STATIC ${SIMDJSON_SOURCES})

add_library(simdjson::simdjson_static ALIAS simdjson_static)

list(APPEND SIMDJSON_LIBRARIES simdjson_static)

# Reuse precompiled headers for static library

if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.16")

target_precompile_headers(simdjson_static REUSE_FROM simdjson)

endif()

endif()

set_target_properties(

simdjson PROPERTIES

VERSION "${SIMDJSON_LIB_VERSION}"

SOVERSION "${SIMDJSON_LIB_SOVERSION}"

# FIXME: symbols should be hidden by default

WINDOWS_EXPORT_ALL_SYMBOLS YES

)

# FIXME: Use proper CMake integration for exports

if(WIN32 AND BUILD_SHARED_LIBS)

target_compile_definitions(

simdjson

PRIVATE SIMDJSON_BUILDING_WINDOWS_DYNAMIC_LIBRARY=1

INTERFACE SIMDJSON_USING_WINDOWS_DYNAMIC_LIBRARY=1

)

endif()

simdjson_add_props(

target_include_directories

PUBLIC "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>"

PRIVATE "$<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>"

)

# Optimize linker settings for faster builds

if(MSVC)

target_link_options(simdjson PRIVATE /INCREMENTAL)

if(CMAKE_BUILD_TYPE STREQUAL "Debug")

target_link_options(simdjson PRIVATE /DEBUG:FASTLINK)

endif()

endif()

if(SIMDJSON_STATIC_REFLECTION)

if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION MATCHES "^21")

execute_process(

COMMAND ${CMAKE_CXX_COMPILER} --version

OUTPUT_VARIABLE CLANG_VERSION_OUTPUT

ERROR_VARIABLE CLANG_VERSION_ERROR

RESULT_VARIABLE CLANG_VERSION_RESULT

)

if(CLANG_VERSION_RESULT EQUAL 0 AND CLANG_VERSION_OUTPUT MATCHES "https://github.com/bloomberg/clang-p2996.git")

set(IS_BLOOMBERG_P2996_CLANG ON)

message(STATUS "Using Bloomberg P2996 Clang fork")

endif()

endif()

# We would like to require C++26, but no compiler supports that!

# This is a hack:

if(IS_BLOOMBERG_P2996_CLANG)

simdjson_add_props(

target_compile_options PUBLIC

-freflection -fexpansion-statements -stdlib=libc++ -std=c++26

)

else()

simdjson_add_props(

target_compile_options PUBLIC

-freflection -std=c++26

)

endif()

else()

simdjson_add_props(target_compile_features PUBLIC cxx_std_11)

endif()

# workaround for GNU GCC poor AVX load/store code generation

if(

CMAKE_CXX_COMPILER_ID STREQUAL "GNU"

AND CMAKE_SYSTEM_PROCESSOR MATCHES "^(i.86|x86(_64)?)$"

)

simdjson_add_props(

target_compile_options PRIVATE

-mno-avx256-split-unaligned-load -mno-avx256-split-unaligned-store

)

endif()

option(SIMDJSON_MINUS_ZERO_AS_FLOAT "Treat -0 as a floating-point value" OFF)

if(SIMDJSON_MINUS_ZERO_AS_FLOAT)

simdjson_add_props(target_compile_definitions PRIVATE SIMDJSON_MINUS_ZERO_AS_FLOAT=1)

endif(SIMDJSON_MINUS_ZERO_AS_FLOAT)

# GCC and Clang have horrendous Debug builds when using SIMD.

# A common fix is to use '-Og' instead.

# bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54412

if(

(CMAKE_CXX_COMPILER_ID STREQUAL "GNU" OR

CMAKE_CXX_COMPILER_ID STREQUAL "Clang" OR

CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")

)

message(STATUS "Adding -Og to compile flag")

simdjson_add_props(

target_compile_options PRIVATE

$<$<CONFIG:DEBUG>:-Og>

)

# We still want to enable development checks in Debug mode

simdjson_add_props(

target_compile_definitions PUBLIC

SIMDJSON_DEVELOPMENT_CHECKS

)

endif()

if(SIMDJSON_ENABLE_THREADS)

find_package(Threads REQUIRED)

simdjson_add_props(target_link_libraries PUBLIC Threads::Threads)

simdjson_add_props(target_compile_definitions PUBLIC SIMDJSON_THREADS_ENABLED=1)

endif()

simdjson_apply_props(simdjson)

if(SIMDJSON_BUILD_STATIC_LIB)

simdjson_apply_props(simdjson_static)

endif()

# ---- Install rules ----

if(SIMDJSON_INSTALL)

include(CMakePackageConfigHelpers)

include(GNUInstallDirs)

if(SIMDJSON_SINGLEHEADER)

install(

FILES singleheader/simdjson.h

DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"

COMPONENT simdjson_Development

)

endif()

install(

TARGETS simdjson

EXPORT simdjsonTargets

RUNTIME COMPONENT simdjson_Runtime

LIBRARY COMPONENT simdjson_Runtime

NAMELINK_COMPONENT simdjson_Development

ARCHIVE COMPONENT simdjson_Development

INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"

)

configure_file(cmake/simdjson-config.cmake.in simdjson-config.cmake @ONLY)

write_basic_package_version_file(

simdjson-config-version.cmake

COMPATIBILITY SameMinorVersion

)

set(

SIMDJSON_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/simdjson"

CACHE STRING "CMake package config location relative to the install prefix"

)

mark_as_advanced(SIMDJSON_INSTALL_CMAKEDIR)

install(

FILES

"${PROJECT_BINARY_DIR}/simdjson-config.cmake"

"${PROJECT_BINARY_DIR}/simdjson-config-version.cmake"

DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"

COMPONENT simdjson_Development

)

install(

EXPORT simdjsonTargets

NAMESPACE simdjson::

DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"

COMPONENT simdjson_Development

)

if(SIMDJSON_BUILD_STATIC_LIB)

install(

TARGETS simdjson_static

EXPORT simdjson_staticTargets

ARCHIVE COMPONENT simdjson_Development

INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"

)

install(

EXPORT simdjson_staticTargets

NAMESPACE simdjson::

DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"

COMPONENT simdjson_Development

)

endif()

# pkg-config

include(cmake/JoinPaths.cmake)

join_paths(PKGCONFIG_INCLUDEDIR "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}")

join_paths(PKGCONFIG_LIBDIR "\${prefix}" "${CMAKE_INSTALL_LIBDIR}")

if(SIMDJSON_ENABLE_THREADS)

set(PKGCONFIG_CFLAGS "-DSIMDJSON_THREADS_ENABLED=1")

if(CMAKE_THREAD_LIBS_INIT)

set(PKGCONFIG_LIBS_PRIVATE "Libs.private: ${CMAKE_THREAD_LIBS_INIT}")

endif()

endif()

configure_file("simdjson.pc.in" "simdjson.pc" @ONLY)

install(

FILES "${CMAKE_CURRENT_BINARY_DIR}/simdjson.pc"

DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig"

)

endif()

#

# CPack

#

if(is_top_project)

set(CPACK_PACKAGE_VENDOR "Daniel Lemire")

set(CPACK_PACKAGE_CONTACT "lemire@gmail.com")

set(CPACK_RESOURCE_FILE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE")

set(CPACK_RESOURCE_FILE_README "${PROJECT_SOURCE_DIR}/README.md")

set(CPACK_RPM_PACKAGE_LICENSE "${PROJECT_SOURCE_DIR}/LICENSE")

set(CPACK_SOURCE_GENERATOR "TGZ;ZIP")

include(CPack)

endif()

# ---- Developer mode extras ----

if(is_top_project AND NOT SIMDJSON_DEVELOPER_MODE)

message(STATUS "Building only the library. Advanced users and contributors may want to turn SIMDJSON_DEVELOPER_MODE to ON, e.g., via -D SIMDJSON_DEVELOPER_MODE=ON.")

elseif(SIMDJSON_DEVELOPER_MODE AND NOT is_top_project)

message(AUTHOR_WARNING "Developer mode in simdjson is intended for the developers of simdjson")

endif()

if(NOT SIMDJSON_DEVELOPER_MODE)

return()

endif()

simdjson_apply_props(simdjson-internal-flags)

set(

SIMDJSON_USER_CMAKECACHE

"${CMAKE_BINARY_DIR}/.simdjson-user-CMakeCache.txt"

)

add_custom_target(

simdjson-user-cmakecache

COMMAND "${CMAKE_COMMAND}"

-D "BINARY_DIR=${CMAKE_BINARY_DIR}"

-D "USER_CMAKECACHE=${SIMDJSON_USER_CMAKECACHE}"

-P "${PROJECT_SOURCE_DIR}/cmake/simdjson-user-cmakecache.cmake"

VERBATIM

)

# Setup tests

enable_testing()

# So we can build just tests with "make all_tests"

add_custom_target(all_tests)

add_subdirectory(windows)

include(cmake/CPM.cmake)

add_subdirectory(dependencies) ## This needs to be before tools because of cxxopts

add_subdirectory(tools) ## This needs to be before tests because of cxxopts

# Data: jsonexamples is left with only the bare essential.

# most of the data has been moved to https://github.com/simdjson/simdjson-data

add_subdirectory(jsonexamples)

if(SIMDJSON_SINGLEHEADER)

add_subdirectory(singleheader)

endif()

#

# Compile tools / tests / benchmarks

#

add_subdirectory(tests)

add_subdirectory(examples)

if(CMAKE_SIZEOF_VOID_P EQUAL 8) # we only include the benchmarks on 64-bit systems.

add_subdirectory(benchmark)

endif()

add_subdirectory(fuzz)

#

# Source files should be just ASCII

#

find_program(FIND_CMD find)

find_program(FILE_CMD file)

find_program(GREP_CMD grep)

if(FIND_CMD AND FILE_CMD AND GREP_CMD)

add_test(

NAME just_ascii

COMMAND sh -c "\

non_ascii=$(${FIND_CMD} include src windows tools singleheader tests examples benchmark \

-path benchmark/checkperf-reference -prune -name '*.h' -o -name '*.cpp' \

-type f -exec ${FILE_CMD} '{}' \; | ${GREP_CMD} -v ASCII); \

if [ -n \"$non_ascii\" ]; then \

echo 'The following files contain non-ASCII characters:'; \

echo \"$non_ascii\"; \

exit 1; \

fi"

WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"

)

else()

message(WARNING "just_ascii test disabled because required tools were not found: find='${FIND_CMD}', file='${FILE_CMD}', grep='${GREP_CMD}'")

endif()

##

## In systems like R, libraries must not use stderr or abort to be acceptable.

## Thus we make it a hard rule that one is not allowed to call abort or stderr.

## The sanitized builds are allowed to abort.

##

if(NOT SIMDJSON_SANITIZE)

find_program(GREP grep)

find_program(NM nm)

if((NOT GREP) OR (NOT NM))

message("grep and nm are unavailable on this system.")

else()

add_test(

NAME "avoid_abort"

# Under FreeBSD, the __cxa_guard_abort symbol may appear but it is fine.

# So we want to look for <space><possibly _>abort as a test.

COMMAND sh -c "${NM} $<TARGET_FILE_NAME:simdjson> | ${GREP} ' _*abort' || exit 0 && exit 1"

WORKING_DIRECTORY ${PROJECT_BINARY_DIR}

)

add_test(

NAME "avoid_cout"

COMMAND sh -c "${NM} $<TARGET_FILE_NAME:simdjson> | ${GREP} ' _*cout' || exit 0 && exit 1"

WORKING_DIRECTORY ${PROJECT_BINARY_DIR}

)

add_test(

NAME "avoid_cerr"

COMMAND sh -c "${NM} $<TARGET_FILE_NAME:simdjson> | ${GREP} ' _*cerr' || exit 0 && exit 1"

WORKING_DIRECTORY ${PROJECT_BINARY_DIR}

)

add_test(

NAME "avoid_printf"

COMMAND sh -c "${NM} $<TARGET_FILE_NAME:simdjson> | ${GREP} ' _*printf' || exit 0 && exit 1"

WORKING_DIRECTORY ${PROJECT_BINARY_DIR}

)

add_test(

NAME "avoid_stdout"

COMMAND sh -c "${NM} $<TARGET_FILE_NAME:simdjson> | ${GREP} stdout || exit 0 && exit 1"

WORKING_DIRECTORY ${PROJECT_BINARY_DIR}

)

add_test(

NAME "avoid_stderr"

COMMAND sh -c "${NM} $<TARGET_FILE_NAME:simdjson> | ${GREP} stderr || exit 0 && exit 1"

WORKING_DIRECTORY ${PROJECT_BINARY_DIR}

)

endif()

endif()