CMake refactor stage1 (#1512)

* Remove CMP0025 policy

This policy is already set to NEW by the minimum required version.

* Use HOMEPAGE_URL in the project call

* Use VERSION in the project call

* Detect if this is the top project

* Port simdjson-user-cmakecache to a CMake script

* Create a developer mode

The SIMDJSON_DEVELOPER_MODE option set to ON will enable targets that
are only useful for developers of simdjson.

* Consolidate root CML commands into logical sections

* Warn about intended use of developer mode

* Prettify the just_ascii test

* Remove redundant CMake variables

* Inline CML contents from include and src

* Raise minimum CMake requirement to 3.14

* Define proper install rules

* Restore thread support variable

* Add BUILD_SHARED_LIBS as a top level only option

* Force developer mode to be on in CI

* Include flags earlier in developer mode

* Set CMAKE_BUILD_TYPE conditionally

CMAKE_BUILD_TYPE is used only by single configuration generators and is
otherwise completely ignored.

* Remove useless static/shared options

simdjson now uses the CMake builtin BUILD_SHARED_LIBS to switch the
built artifact's type.

* Remove unused CMAKE_MODULE_PATH variable

* Refactor implementation switching into a module

* Factor exception option out into a module

* Reformat simdjson-flags.cmake

* Rename simdjson-flags to developer-options

* Accumulate properties into an include module

This is done this way to avoid using utility targets that must be
exported and installed, which could potentially be misused by users of
the library.

* Port impl definitions to props

* Port exception options to props

* Lift normal options to the top

* Port developer options to props

* Remove simdjson-flags from benchmark

* Document the developer mode in HACKING

* Fix include path in installed config file

* Fix formatting of prop commands

* Fix tests that include .cpp files

* Change GCC AVX fixes back to compile options

* Deprecate SIMDJSON_BUILD_STATIC

* Always link fuzz targets to simdjson

* Install CMake from simdjson's debian repo

* Add gnupg for apt-key

* Make sure ASan link flags come first

* Pass CI env variable to cmake invocation

* Install package for apt-add-repository

* Remove return() from flush macro

* Use directory level commands instead of props

* Restore the github repository variable

* Set developer mode unconditionally for checkperf

The CI env variable is only set in the CI and this target is always run
in developer mode.

* Attempt to fix ODR violation in parsing checks

These tests were compiling the simdjson.cpp file again and linking to
the simdjson library target causes ODR violations.

Instead of linking to the target, just inherit its props.

* Move variables before the source dir

* Mark props to be flushed after adding more

* Use props for every command for the library

* Use keyword form for linking libs

* Handle deprecation of SIMDJSON_JUST_LIBRARY

* Handle deprecations in a separate module

Co-authored-by: friendlyanon <friendlyanon@users.noreply.github.com>

.github/workflows/power-fuzz.yml

@@ -32,7 +32,12 @@ jobs:
           run: |
             export CLANGSUFFIX="-7"
             apt-get -qq update
-            apt-get install -q -y clang-7 libfuzzer-7-dev cmake git wget zip ninja-build
+            apt-get install -q -y clang-7 libfuzzer-7-dev git wget zip ninja-build gnupg software-properties-common
+            wget -q -O - "https://raw.githubusercontent.com/simdjson/debian-ppa/master/key.gpg" | apt-key add -
+            apt-add-repository "deb https://raw.githubusercontent.com/simdjson/debian-ppa/master simdjson main"
+            apt-get -qq update
+            apt-get purge cmake cmake-data
+            apt-get -t simdjson -y install cmake
             mkdir -p build ; cd build
             cmake .. -GNinja \
                   -DCMAKE_CXX_COMPILER=clang++$CLANGSUFFIX \

CMakeLists.txt

@@ -1,76 +1,224 @@
-cmake_minimum_required(VERSION 3.13)
+cmake_minimum_required(VERSION 3.14)
-# CMP0025: Compiler id for Apple Clang is now AppleClang.
+
-# https://cmake.org/cmake/help/v3.17/policy/CMP0025.html
+project(
-cmake_policy(SET CMP0025 NEW)
+    simdjson
-project(simdjson
+    # The version number is modified by tools/release.py
-  DESCRIPTION "Parsing gigabytes of JSON per second"
+    VERSION 0.9.1
-  LANGUAGES CXX C
+    DESCRIPTION "Parsing gigabytes of JSON per second"
+    HOMEPAGE_URL "https://simdjson.org/"
+    LANGUAGES CXX C
 )
 
-set(PROJECT_VERSION_MAJOR 0)
+set(SIMDJSON_GITHUB_REPOSITORY "https://github.com/simdjson/simdjson")
-set(PROJECT_VERSION_MINOR 9)
+
-set(PROJECT_VERSION_PATCH 1)
+string(
-set(SIMDJSON_SEMANTIC_VERSION "0.9.1" CACHE STRING "simdjson semantic version")
+    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 "8.0.0" CACHE STRING "simdjson library version")
 set(SIMDJSON_LIB_SOVERSION "8" CACHE STRING "simdjson library soversion")
-set(SIMDJSON_GITHUB_REPOSITORY https://github.com/simdjson/simdjson)
-
-include(GNUInstallDirs)
-include(cmake/simdjson-flags.cmake)
-include(cmake/simdjson-user-cmakecache.cmake)
-
-# So we can build just tests with "make all_tests"
-add_custom_target(all_tests)
-
-if(SIMDJSON_JUST_LIBRARY)
-  message( STATUS "Building just the library, omitting all tests, tools and benchmarks." )
-else(SIMDJSON_JUST_LIBRARY)
-  # Setup tests
-  enable_testing()
-  add_subdirectory(jsonchecker)
-  add_subdirectory(jsonexamples)
-  add_library(test-data INTERFACE)
-  target_link_libraries(test-data INTERFACE jsonchecker-data jsonchecker-minefield-data jsonexamples-data)
-endif(SIMDJSON_JUST_LIBRARY)
-
-# Create the top level simdjson library (must be done at this level to use both src/ and include/
-# directories) and tools
-#
-
-add_subdirectory(include)
-add_subdirectory(src)
-add_subdirectory(windows)
-if(NOT(SIMDJSON_JUST_LIBRARY))
-  add_subdirectory(dependencies) ## This needs to be before tools because of cxxopts
-  add_subdirectory(tools)  ## This needs to be before tests because of cxxopts
-  add_subdirectory(singleheader)
-endif()
-install(FILES singleheader/simdjson.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 
 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()
+
+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()
+
+if(is_top_project)
+  option(SIMDJSON_DEVELOPER_MODE "Enable targets for developing simdjson" OFF)
+  option(BUILD_SHARED_LIBS "Build simdjson as a shared library" OFF)
+
+  if("$ENV{CI}")
+    set(SIMDJSON_DEVELOPER_MODE ON CACHE INTERNAL "")
+  endif()
+endif()
+
+include(cmake/handle-deprecations.cmake)
+
+if(SIMDJSON_DEVELOPER_MODE)
+  include(cmake/developer-options.cmake)
+endif()
+
+# ---- simdjson library ----
+
+add_library(simdjson src/simdjson.cpp)
+add_library(simdjson::simdjson ALIAS simdjson)
+
+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(MSVC 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>"
+)
+
+simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
+
+# 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()
+
+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)
+
+# ---- Install rules ----
+
 include(CMakePackageConfigHelpers)
-configure_package_config_file("${PROJECT_SOURCE_DIR}/cmake/simdjson-config.cmake.in"
+include(GNUInstallDirs)
-      "${PROJECT_BINARY_DIR}/simdjson-config.cmake"
+
-      INSTALL_DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/simdjson"
+install(
-      NO_SET_AND_CHECK_MACRO
+    FILES singleheader/simdjson.h
-      NO_CHECK_REQUIRED_COMPONENTS_MACRO)
+    DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+    COMPONENT simdjson_Development
+)
+
+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(
-      "${PROJECT_BINARY_DIR}/simdjson-config-version.cmake"
+    simdjson-config-version.cmake
-      VERSION ${SIMDJSON_SEMANTIC_VERSION}
+    COMPATIBILITY SameMinorVersion
-      COMPATIBILITY SameMinorVersion)
+)
-install(FILES "${PROJECT_BINARY_DIR}/simdjson-config.cmake"
+
-              "${PROJECT_BINARY_DIR}/simdjson-config-version.cmake"
+set(
-        DESTINATION "${CMAKE_INSTALL_LIBDIR}/cmake/simdjson")
+    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 example_Development
+)
+
+#
+# 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(NOT SIMDJSON_DEVELOPER_MODE)
+  return()
+elseif(NOT is_top_project)
+  message(AUTHOR_WARNING "Developer mode is intended for developers of simdjson")
+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(jsonchecker)
+add_subdirectory(jsonexamples)
+add_library(test-data INTERFACE)
+target_link_libraries(test-data INTERFACE jsonchecker-data jsonchecker-minefield-data jsonexamples-data)
+
+add_subdirectory(windows)
+add_subdirectory(dependencies) ## This needs to be before tools because of cxxopts
+add_subdirectory(tools)  ## This needs to be before tests because of cxxopts
+add_subdirectory(singleheader)
 
 #
 # Compile tools / tests / benchmarks
 #
-if(NOT(SIMDJSON_JUST_LIBRARY))
+add_subdirectory(tests)
-  add_subdirectory(tests)
+add_subdirectory(examples)
-  add_subdirectory(examples)
+add_subdirectory(benchmark)
-  add_subdirectory(benchmark)
+add_subdirectory(fuzz)
-  add_subdirectory(fuzz)
-endif()
 
 #
 # Source files should be just ASCII
@@ -78,29 +226,59 @@ endif()
 find_program(FIND find)
 find_program(FILE file)
 find_program(GREP grep)
-if((FIND) AND (FILE) AND (GREP))
+if(FIND AND FILE AND GREP)
-    add_test(
+  add_test(
-      NAME "just_ascii"
+      NAME just_ascii
-      COMMAND sh -c "${FIND}  include src windows tools singleheader tests examples benchmark -path benchmark/checkperf-reference -prune -name '*.h'  -o -name '*.cpp' -type f  -exec ${FILE} '{}' \; |${GREP} -v ASCII || exit 0  && exit 1"
+      COMMAND sh -c "\
-      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+${FIND} include src windows tools singleheader tests examples benchmark \
-    )
+-path benchmark/checkperf-reference -prune -name '*.h' -o -name '*.cpp' \
+-type f -exec ${FILE} '{}' \; | ${GREP} -qv ASCII || exit 0  && exit 1"
+      WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
+  )
 endif()
 
-
+##
-#
+## In systems like R, libraries must not use stderr or abort to be acceptable.
-# CPack
+## Thus we make it a hard rule that one is not allowed to call abort or stderr.
-#
+## The sanitized builds are allowed to abort.
-set(CPACK_PACKAGE_VENDOR "Daniel Lemire")
+##
-set(CPACK_PACKAGE_CONTACT "lemire@gmail.com")
+if(NOT SIMDJSON_SANITIZE)
-set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "Parsing gigabytes of JSON per second")
+  find_program(GREP grep)
-set(CPACK_PACKAGE_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
+  find_program(NM nm)
-set(CPACK_PACKAGE_VERSION_MINOR ${PROJECT_VERSION_MINOR})
+  if((NOT GREP) OR (NOT NM))
-set(CPACK_PACKAGE_VERSION_PATCH ${PROJECT_VERSION_PATCH})
+    message("grep and nm are unavailable on this system.")
-set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
+  else()
-set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
+    add_test(
-
+      NAME "avoid_abort"
-set(CPACK_RPM_PACKAGE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
+      # 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.
-set(CPACK_SOURCE_GENERATOR "TGZ;ZIP")
+      COMMAND sh -c "${NM}  $<TARGET_FILE_NAME:simdjson> |  ${GREP} ' _*abort' || exit 0  && exit 1"
-
+      WORKING_DIRECTORY ${PROJECT_BINARY_DIR}
-include(CPack)
+    )
+    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()

HACKING.md

@@ -32,6 +32,18 @@ Stage 1 also does unicode validation.
 
 Stage 2 handles all of the rest: number parsings, recognizing atoms like true, false, null, and so forth.
 
+Developer mode
+--------------
+
+Build system targets that are only useful for developers of the simdjson
+library are behind the `SIMDJSON_DEVELOPER_MODE` option. Enabling this option
+makes tests, examples, benchmarks and other developer targets available. Not
+enabling this option means that you are a consumer of simdjson and thus you
+only get the library targets and options.
+
+Developer mode is forced to be on when the `CI` environment variable is set to
+a value that CMake recognizes as "on", which is set to `true` in all of the CI
+workflows used by simdjson.
 
 Directory Structure and Source
 ------------------------------
@@ -74,7 +86,7 @@ Other important files and directories:
   ```bash
   mkdir build
   cd build
-  cmake ..
+  cmake -D SIMDJSON_DEVELOPER_MODE=ON ..
   cmake --build . --config Release
   benchmark/parse ../jsonexamples/twitter.json
   ```
@@ -82,11 +94,11 @@ Other important files and directories:
   ```bash
   mkdir build
   cd build
-  cmake ..
+  cmake -D SIMDJSON_DEVELOPER_MODE=ON ..
   cmake --build . --target bench_parse_call --config Release
   ./benchmark/bench_parse_call
   ```
-  The last line becomes `./benchmark/Release/bench_parse_call.exe` under Windows. Under Windows, you can also build with the clang compiler by adding `-T ClangCL` to the call to `cmake ..`: `cmake .. - TClangCL`.
+  The last line becomes `./benchmark/Release/bench_parse_call.exe` under Windows. Under Windows, you can also build with the clang compiler by adding `-T ClangCL` to the call to `cmake ..`: `cmake -T ClangCL ..`.
 * **fuzz:** The source for fuzz testing. This lets us explore important edge and middle cases
 * **fuzz:** The source for fuzz testing. This lets us explore important edge and middle cases
   automatically, and is run in CI.
@@ -168,7 +180,7 @@ systematically regenerated on releases. To ensure you have the latest code, you
 ```bash
 mkdir build
 cd build
-cmake ..
+cmake -D SIMDJSON_DEVELOPER_MODE=ON ..
 cmake --build . # needed, because currently dependencies do not work fully for the amalgamate target
 cmake --build . --target amalgamate
 ```
@@ -209,31 +221,31 @@ Building: While in the project repository, do the following:
 ```
 mkdir build
 cd build
-cmake ..
+cmake -D SIMDJSON_DEVELOPER_MODE=ON ..
 cmake --build .
 ctest
 ```
 
-CMake will build a library. By default, it builds a shared library (e.g., libsimdjson.so on Linux).
+CMake will build a library. By default, it builds a static library (e.g., libsimdjson.a on Linux).
 
-You can build a static library:
+You can build a shared library:
 
 ```
-mkdir buildstatic
+mkdir buildshared
-cd buildstatic
+cd buildshared
-cmake -DSIMDJSON_BUILD_STATIC=ON ..
+cmake -D BUILD_SHARED_LIBS=ON -D SIMDJSON_DEVELOPER_MODE=ON ..
 cmake --build .
 ctest
 ```
 
-In some cases, you may want to specify your compiler, especially if the default compiler on your system is too old.  You need to tell cmake which compiler you wish to use by setting the CC and CXX variables. Under bash, you can do so with commands such as `export CC=gcc-7` and `export CXX=g++-7`. You can also do it as part of the `cmake` command: `cmake .. -DCMAKE_CXX_COMPILER=g++`.  You may proceed as follows:
+In some cases, you may want to specify your compiler, especially if the default compiler on your system is too old.  You need to tell cmake which compiler you wish to use by setting the CC and CXX variables. Under bash, you can do so with commands such as `export CC=gcc-7` and `export CXX=g++-7`. You can also do it as part of the `cmake` command: `cmake -DCMAKE_CXX_COMPILER=g++ ..`.  You may proceed as follows:
 
 ```
 brew install gcc@8
 mkdir build
 cd build
 export CXX=g++-8 CC=gcc-8
-cmake ..
+cmake -D SIMDJSON_DEVELOPER_MODE=ON ..
 cmake --build .
 ctest
 ```
@@ -269,7 +281,7 @@ Furthermore, if you have installed LLVM clang on Windows, for example as a compo
 
 - `mkdir build`
 - `cd build`
-- `cmake ..  -T ClangCL`
+- `cmake -T ClangCL ..`
 - `cmake --build . -config Release`
 
 

benchmark/CMakeLists.txt

@@ -1,6 +1,6 @@
 include_directories( . linux )
 link_libraries(simdjson-windows-headers test-data)
-link_libraries(simdjson simdjson-flags)
+link_libraries(simdjson)
 
 add_executable(benchfeatures benchfeatures.cpp)
 add_executable(get_corpus_benchmark get_corpus_benchmark.cpp)

benchmark/checkperf.cmake

@@ -61,7 +61,13 @@ if (Git_FOUND AND (GIT_VERSION_STRING VERSION_GREATER  "2.1.4") AND (NOT CMAKE_G
     OUTPUT ${SIMDJSON_CHECKPERF_DIR}/build/cmake_install.cmake # We make many things but this seems the most cross-platform one we can depend on
     COMMAND
     ${CMAKE_COMMAND} -E env CXX=${CMAKE_CXX_COMPILER} CC=${CMAKE_C_COMPILER}
-    ${CMAKE_COMMAND} -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE} -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_COMPETITION=OFF -G ${CMAKE_GENERATOR} ..
+    ${CMAKE_COMMAND}
+    -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+    -DSIMDJSON_GOOGLE_BENCHMARKS=OFF
+    -DSIMDJSON_COMPETITION=OFF
+    -DSIMDJSON_DEVELOPER_MODE=YES
+    -G ${CMAKE_GENERATOR}
+    ..
     WORKING_DIRECTORY ${SIMDJSON_CHECKPERF_DIR}/build
     DEPENDS ${SIMDJSON_CHECKPERF_DIR}/build/CMakeCache.txt
   )

cmake/developer-options.cmake

@@ -0,0 +1,171 @@
+#
+# Flags used by exes and by the simdjson library (project-wide flags)
+#
+add_library(simdjson-internal-flags INTERFACE)
+
+option(SIMDJSON_SANITIZE_UNDEFINED "Sanitize undefined behavior" OFF)
+if(SIMDJSON_SANITIZE_UNDEFINED)
+  add_compile_options(-fsanitize=undefined -fno-sanitize-recover=all)
+  add_link_options(-fsanitize=undefined -fno-sanitize-recover=all)
+endif()
+
+option(SIMDJSON_SANITIZE "Sanitize addresses" OFF)
+if(SIMDJSON_SANITIZE)
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+    message(STATUS "The address sanitizer under Apple's clang appears to be \
+incompatible with the undefined-behavior sanitizer.")
+    message(STATUS "You may set SIMDJSON_SANITIZE_UNDEFINED to sanitize \
+undefined behavior.")
+    add_compile_options(
+        -fsanitize=address -fno-omit-frame-pointer -fno-sanitize-recover=all
+    )
+    add_compile_definitions(ASAN_OPTIONS=detect_leaks=1)
+    link_libraries(
+        -fsanitize=address -fno-omit-frame-pointer -fno-sanitize-recover=all
+    )
+  else()
+    message(
+        STATUS
+        "Setting both the address sanitizer and the undefined sanitizer."
+    )
+    add_compile_options(
+        -fsanitize=address -fno-omit-frame-pointer
+        -fsanitize=undefined -fno-sanitize-recover=all
+    )
+    link_libraries(
+        -fsanitize=address -fno-omit-frame-pointer
+        -fsanitize=undefined -fno-sanitize-recover=all
+    )
+  endif()
+
+  # Ubuntu bug for GCC 5.0+ (safe for all versions)
+  if(CMAKE_COMPILER_IS_GNUCC)
+    link_libraries(-fuse-ld=gold)
+  endif()
+endif()
+
+if(SIMDJSON_SANITIZE_THREADS)
+  message(STATUS "Setting both the thread sanitizer \
+and the undefined-behavior sanitizer.")
+  add_compile_options(
+      -fsanitize=thread -fsanitize=undefined -fno-sanitize-recover=all
+  )
+  link_libraries(
+      -fsanitize=thread -fsanitize=undefined -fno-sanitize-recover=all
+  )
+
+  # Ubuntu bug for GCC 5.0+ (safe for all versions)
+  if(CMAKE_COMPILER_IS_GNUCC)
+    link_libraries(-fuse-ld=gold)
+  endif()
+endif()
+
+get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG)
+if(NOT is_multi_config AND NOT CMAKE_BUILD_TYPE)
+  # Deliberately not including SIMDJSON_SANITIZE_THREADS since thread behavior
+  # depends on the build type.
+  if(SIMDJSON_SANITIZE OR SIMDJSON_SANITIZE_UNDEFINED)
+    message(STATUS "No build type selected and you have enabled the sanitizer, \
+default to Debug. Consider setting CMAKE_BUILD_TYPE.")
+    set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
+  else()
+    message(STATUS "No build type selected, default to Release")
+    set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+  endif()
+endif()
+
+if(NOT MSVC)
+  option(SIMDJSON_USE_LIBCPP "Use the libc++ library" OFF)
+endif()
+
+if(MSVC AND BUILD_SHARED_LIBS)
+  # This will require special handling.
+  set(SIMDJSON_WINDOWS_DLL TRUE)
+endif()
+
+# We compile tools, tests, etc. with C++ 17. Override yourself if you need on a
+# target.
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+set(CMAKE_MACOSX_RPATH OFF)
+set(CMAKE_THREAD_PREFER_PTHREAD ON)
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+
+# LTO seems to create all sorts of fun problems. Let us
+# disable temporarily.
+#include(CheckIPOSupported)
+#check_ipo_supported(RESULT ltoresult)
+#if(ltoresult)
+#  set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+#endif()
+
+option(SIMDJSON_VISUAL_STUDIO_BUILD_WITH_DEBUG_INFO_FOR_PROFILING "\
+Under Visual Studio, add Zi to the compile flag and DEBUG to the link file to \
+add debugging information to the release build for easier profiling inside \
+tools like VTune" OFF)
+if(MSVC)
+  if(MSVC_TOOLSET_VERSION STRLESS "142")
+    set(SIMDJSON_LEGACY_VISUAL_STUDIO TRUE)
+    message (STATUS "A legacy Visual Studio version was detected. \
+We recommend Visual Studio 2019 or better on a 64-bit system.")
+  endif()
+  if(MSVC_TOOLSET_VERSION STREQUAL "140")
+    # Visual Studio 2015 issues warnings and we tolerate it
+    # cmake -G "Visual Studio 14" ..
+    target_compile_options(simdjson-internal-flags INTERFACE /W0 /sdl)
+  else()
+    # Recent version of Visual Studio expected (2017, 2019...). Prior versions
+    # are unsupported.
+    # https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-4-c4714?view=vs-2019
+    target_compile_options(simdjson-internal-flags INTERFACE /WX /W3 /sdl /w34714)
+  endif()
+  if(SIMDJSON_VISUAL_STUDIO_BUILD_WITH_DEBUG_INFO_FOR_PROFILING)
+    add_link_options(/DEBUG)
+    add_compile_options(/Zi)
+  endif()
+else()
+  if(NOT WIN32)
+    target_compile_options(simdjson-internal-flags INTERFACE -fPIC)
+  endif()
+  target_compile_options(
+      simdjson-internal-flags INTERFACE
+      -Werror -Wall -Wextra -Weffc++ -Wsign-compare -Wshadow -Wwrite-strings
+      -Wpointer-arith -Winit-self -Wconversion -Wno-sign-conversion
+  )
+endif()
+
+#
+# Other optional flags
+#
+option(SIMDJSON_BASH "Allow usage of bash within CMake" ON)
+
+option(
+    SIMDJSON_VERBOSE_LOGGING
+    "Enable verbose logging for internal simdjson library development."
+    OFF
+)
+if(SIMDJSON_VERBOSE_LOGGING)
+  add_compile_definitions(SIMDJSON_VERBOSE_LOGGING=1
+  )
+endif()
+
+if(SIMDJSON_USE_LIBCPP)
+  link_libraries(-stdlib=libc++ -lc++abi)
+  # instead of the above line, we could have used
+  # set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++
+  # -lc++abi")
+  # The next line is needed empirically.
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
+  # we update CMAKE_SHARED_LINKER_FLAGS, this gets updated later as well
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -lc++abi")
+endif()
+
+# prevent shared libraries from depending on Intel provided libraries
+if(CMAKE_C_COMPILER_ID MATCHES "Intel")
+  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -static-intel")
+endif()
+
+include(CheckSymbolExists)
+check_symbol_exists(fork unistd.h HAVE_POSIX_FORK)
+check_symbol_exists(wait sys/wait.h HAVE_POSIX_WAIT)

cmake/exception-flags.cmake

@@ -0,0 +1,28 @@
+option(SIMDJSON_EXCEPTIONS "Enable simdjson's exception-throwing interface" ON)
+if(NOT SIMDJSON_EXCEPTIONS)
+  message(STATUS "simdjson exception interface turned off. \
+Code that does not check error codes will not compile.")
+  simdjson_add_props(target_compile_definitions PUBLIC SIMDJSON_EXCEPTIONS=0)
+  if(MSVC)
+    if(NOT is_top_project)
+      message(AUTHOR_WARNING "Turning SIMDJSON_EXCEPTIONS off requires \
+editing CMAKE_CXX_FLAGS")
+    endif()
+
+    # CMake currently /EHsc as a default flag in CMAKE_CXX_FLAGS on MSVC.
+    # Replacing this with a more general abstraction is a WIP
+    # (see https://gitlab.kitware.com/cmake/cmake/-/issues/20610)
+    # /EHs enables standard C++ stack unwinding when catching exceptions
+    # (non-structured exception handling)
+    # /EHc used in conjection with /EHs indicates that extern "C" functions
+    # never throw (terminate-on-throw)
+    # Here, we disable both with the - argument negation operator
+    string(REPLACE "/EHsc" "/EHs-c-" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
+
+    # Because we cannot change the flag above on an invidual target (yet), the
+    # definition below must similarly be added globally
+    add_definitions(-D_HAS_EXCEPTIONS=0)
+  elseif(CMAKE_COMPILER_IS_GNUCC)
+    simdjson_add_props(target_link_libraries PRIVATE -fno-exceptions)
+  endif()
+endif()

cmake/handle-deprecations.cmake

@@ -0,0 +1,23 @@
+if(DEFINED SIMDJSON_BUILD_STATIC)
+  message(DEPRECATION "SIMDJSON_BUILD_STATIC is deprecated, setting \
+BUILD_SHARED_LIBS with its value and unsetting it")
+  set(shared ON)
+  if(SIMDJSON_BUILD_STATIC)
+    set(shared OFF)
+  endif()
+
+  set(BUILD_SHARED_LIBS "${shared}" CACHE BOOL "" FORCE)
+  unset(SIMDJSON_BUILD_STATIC CACHE)
+endif()
+
+if(DEFINED SIMDJSON_JUST_LIBRARY)
+  message(DEPRECATION "SIMDJSON_JUST_LIBRARY is deprecated, setting \
+SIMDJSON_DEVELOPER_MODE with its value and unsetting it")
+  set(dev_mode ON)
+  if(SIMDJSON_JUST_LIBRARY)
+    set(dev_mode OFF)
+  endif()
+
+  set(SIMDJSON_DEVELOPER_MODE "${dev_mode}" CACHE BOOL "" FORCE)
+  unset(SIMDJSON_JUST_LIBRARY CACHE)
+endif()

cmake/implementation-flags.cmake

@@ -0,0 +1,106 @@
+#
+# Implementation selection
+#
+set(SIMDJSON_ALL_IMPLEMENTATIONS fallback westmere haswell arm64 ppc64)
+
+set(
+    SIMDJSON_IMPLEMENTATION ""
+    CACHE STRING "\
+Semicolon-separated list of implementations to include \
+(${SIMDJSON_ALL_IMPLEMENTATIONS}). If this is not set, any implementations \
+that are supported at compile time and may be selected at runtime will be \
+included."
+)
+set(
+    SIMDJSON_EXCLUDE_IMPLEMENTATION ""
+    CACHE STRING "\
+Semicolon-separated list of implementations to exclude \
+(haswell/westmere/arm64/ppc64/fallback). By default, excludes any \
+implementations that are unsupported at compile time or cannot be selected at \
+runtime."
+)
+
+foreach(var IN ITEMS IMPLEMENTATION EXCLUDE_IMPLEMENTATION)
+  set(var "SIMDJSON_${var}")
+  foreach(impl IN LISTS "${var}")
+    if(NOT impl IN_LIST SIMDJSON_ALL_IMPLEMENTATIONS)
+      message(ERROR "\
+Implementation ${impl} found in ${var} not supported by simdjson. \
+Possible implementations: ${SIMDJSON_ALL_IMPLEMENTATIONS}")
+    endif()
+  endforeach()
+endforeach()
+
+macro(flag_action action var val)
+  message(STATUS "${action} implementation ${impl} due to ${var}=${${var}}")
+  simdjson_add_props(
+      target_compile_definitions PUBLIC
+      "SIMDJSON_IMPLEMENTATION_${impl_upper}=${val}"
+  )
+endmacro()
+
+foreach(impl IN LISTS SIMDJSON_ALL_IMPLEMENTATIONS)
+  string(TOUPPER "${impl}" impl_upper)
+  if(impl IN_LIST SIMDJSON_EXCLUDE_IMPLEMENTATION)
+    flag_action(Excluding SIMDJSON_EXCLUDE_IMPLEMENTATION 0)
+  elseif(impl IN_LIST SIMDJSON_IMPLEMENTATION)
+    flag_action(Including SIMDJSON_IMPLEMENTATION 1)
+  elseif(SIMDJSON_IMPLEMENTATION)
+    flag_action(Excluding SIMDJSON_IMPLEMENTATION 0)
+  endif()
+endforeach()
+
+# TODO make it so this generates the necessary compiler flags to select the
+# given impl as the builtin automatically!
+set(
+    SIMDJSON_BUILTIN_IMPLEMENTATION ""
+    CACHE STRING "\
+Select the implementation that will be used for user code. Defaults to the \
+most universal implementation in SIMDJSON_IMPLEMENTATION (in the order \
+${SIMDJSON_ALL_IMPLEMENTATIONS}) if specified; otherwise, by default the \
+compiler will pick the best implementation that can always be selected given \
+the compiler flags."
+)
+if(NOT SIMDJSON_BUILTIN_IMPLEMENTATION STREQUAL "")
+  simdjson_add_props(
+      target_compile_definitions PUBLIC
+      "SIMDJSON_BUILTIN_IMPLEMENTATION=${SIMDJSON_BUILTIN_IMPLEMENTATION}"
+  )
+else()
+  # Pick the most universal implementation out of the selected implementations
+  # (if any)
+  foreach(impl IN LISTS SIMDJSON_ALL_IMPLEMENTATIONS)
+    if(
+        impl IN_LIST SIMDJSON_IMPLEMENTATION
+        AND NOT impl IN_LIST SIMDJSON_EXCLUDE_IMPLEMENTATION
+    )
+      message(STATUS "\
+Selected implementation ${impl} as builtin implementation based on \
+${SIMDJSON_IMPLEMENTATION}")
+      simdjson_add_props(
+          target_compile_definitions PUBLIC
+          "SIMDJSON_BUILTIN_IMPLEMENTATION=${impl}"
+      )
+      break()
+    endif()
+  endforeach()
+endif()
+
+foreach(impl IN LISTS SIMDJSON_ALL_IMPLEMENTATIONS)
+  string(TOUPPER "${impl}" impl_upper)
+  option(
+      "SIMDJSON_IMPLEMENTATION_${impl_upper}"
+      "Include the ${impl} implementation"
+      ON
+  )
+  mark_as_advanced("SIMDJSON_IMPLEMENTATION_${impl_upper}")
+  if(NOT "${SIMDJSON_IMPLEMENTATION_${impl_upper}}")
+    message(DEPRECATION "\
+SIMDJSON_IMPLEMENTATION_${impl_upper} is deprecated. \
+Use SIMDJSON_IMPLEMENTATION=-${impl} instead")
+     simdjson_add_props(
+        target_compile_definitions PUBLIC
+        "SIMDJSON_IMPLEMENTATION_${impl_upper}=0"
+    )
+  endif()
+endforeach()

cmake/simdjson-config.cmake.in

@@ -1,9 +1,6 @@
-@PACKAGE_INIT@
-
 include(CMakeFindDependencyMacro)
-if(@SIMDJSON_ENABLE_THREADS@)
+if("@SIMDJSON_ENABLE_THREADS@")
-    set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
+  find_dependency(Threads)
-    find_dependency(Threads)
 endif()
-# Import targets.
+
-include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@-targets.cmake")
+include("${CMAKE_CURRENT_LIST_DIR}/simdjsonTargets.cmake")

cmake/simdjson-flags.cmake

@@ -1,275 +0,0 @@
-
-if(CMAKE_SOURCE_DIR STREQUAL CMAKE_CURRENT_SOURCE_DIR)
-  message (STATUS "The simdjson repository appears to be standalone.")
-  option(SIMDJSON_JUST_LIBRARY "Build just the library, omit tests, tools and benchmarks" OFF)
-  message (STATUS "By default, we attempt to build everything.")
-else()
-  message (STATUS "The simdjson repository appears to be used as a subdirectory.")
-  option(SIMDJSON_JUST_LIBRARY "Build just the library, omit tests, tools and benchmarks" ON)
-  message (STATUS "By default, we just build the library.")
-endif()
-
-#
-# Flags used by exes and by the simdjson library (project-wide flags)
-#
-add_library(simdjson-flags INTERFACE)
-add_library(simdjson-internal-flags INTERFACE)
-target_link_libraries(simdjson-internal-flags INTERFACE simdjson-flags)
-
-option(SIMDJSON_SANITIZE_UNDEFINED "Sanitize undefined behavior" OFF)
-if(SIMDJSON_SANITIZE_UNDEFINED)
-  target_compile_options(simdjson-flags INTERFACE -fsanitize=undefined -fno-sanitize-recover=all)
-  target_link_libraries(simdjson-flags INTERFACE -fsanitize=undefined -fno-sanitize-recover=all)
-endif()
-
-option(SIMDJSON_SANITIZE "Sanitize addresses" OFF)
-if(SIMDJSON_SANITIZE)
-  if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
-    message(STATUS "The address sanitizer under Apple's clang appears to be incompatible with the undefined-behavior sanitizer.")
-    message(STATUS "You may set SIMDJSON_SANITIZE_UNDEFINED to sanitize undefined behavior.")
-    target_compile_options(simdjson-flags INTERFACE -fsanitize=address  -fno-omit-frame-pointer -fno-sanitize-recover=all)
-    target_compile_definitions(simdjson-flags INTERFACE ASAN_OPTIONS=detect_leaks=1)
-    target_link_libraries(simdjson-flags INTERFACE -fsanitize=address  -fno-omit-frame-pointer -fno-sanitize-recover=all)
-  else()
-    message(STATUS "Setting both the address sanitizer and the undefined sanitizer.")
-    target_compile_options(simdjson-flags INTERFACE -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined -fno-sanitize-recover=all)
-    target_link_libraries(simdjson-flags INTERFACE -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined -fno-sanitize-recover=all)
-  endif()
-  # Ubuntu bug for GCC 5.0+ (safe for all versions)
-  if (CMAKE_COMPILER_IS_GNUCC)
-    target_link_libraries(simdjson-flags INTERFACE -fuse-ld=gold)
-  endif()
-endif()
-
-
-if(SIMDJSON_SANITIZE_THREADS)
-  message(STATUS "Setting both the thread sanitizer and the undefined-behavior sanitizer.")
-  target_compile_options(simdjson-flags INTERFACE -fsanitize=thread -fsanitize=undefined -fno-sanitize-recover=all)
-  target_link_libraries(simdjson-flags INTERFACE -fsanitize=thread -fsanitize=undefined -fno-sanitize-recover=all)
-
-  # Ubuntu bug for GCC 5.0+ (safe for all versions)
-  if (CMAKE_COMPILER_IS_GNUCC)
-    target_link_libraries(simdjson-flags INTERFACE -fuse-ld=gold)
-  endif()
-endif()
-
-if (NOT CMAKE_BUILD_TYPE)
-  # Deliberately not including SIMDJSON_SANITIZE_THREADS since thread behavior depends on the build type.
-  if(SIMDJSON_SANITIZE OR SIMDJSON_SANITIZE_UNDEFINED)
-    message(STATUS "No build type selected and you have enabled the sanitizer, default to Debug. Consider setting CMAKE_BUILD_TYPE.")
-    set(CMAKE_BUILD_TYPE Debug CACHE STRING "Choose the type of build." FORCE)
-  else()
-    message(STATUS "No build type selected, default to Release")
-    set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
-  endif()
-endif()
-
-if(MSVC)
-  option(SIMDJSON_BUILD_STATIC "Build a static library" ON) # turning it on disables the production of a dynamic library
-else()
-  option(SIMDJSON_BUILD_STATIC "Build a static library" OFF) # turning it on disables the production of a dynamic library
-  option(SIMDJSON_USE_LIBCPP "Use the libc++ library" OFF)
-endif()
-
-if(MSVC AND NOT(SIMDJSON_BUILD_STATIC))
-  # This will require special handling.
-  set(SIMDJSON_WINDOWS_DLL TRUE)
-endif()
-
-set(CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/tools/cmake")
-
-# We compile tools, tests, etc. with C++ 17. Override yourself if you need on a target.
-set(CMAKE_CXX_STANDARD 17)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-set(CMAKE_CXX_EXTENSIONS OFF)
-set(CMAKE_MACOSX_RPATH OFF)
-set(CMAKE_THREAD_PREFER_PTHREAD ON)
-set(THREADS_PREFER_PTHREAD_FLAG ON)
-
-# LTO seems to create all sorts of fun problems. Let us
-# disable temporarily.
-#include(CheckIPOSupported)
-#check_ipo_supported(RESULT ltoresult)
-#if(ltoresult)
-#  set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
-#endif()
-
-option(SIMDJSON_VISUAL_STUDIO_BUILD_WITH_DEBUG_INFO_FOR_PROFILING "Under Visual Studio, add Zi to the compile flag and DEBUG to the link file to add debugging information to the release build for easier profiling inside tools like VTune" OFF)
-if(MSVC)
-  if("${MSVC_TOOLSET_VERSION}" STRLESS "142")
-    set(SIMDJSON_LEGACY_VISUAL_STUDIO TRUE)
-    message (STATUS "A legacy Visual Studio version was detected. We recommend Visual Studio 2019 or better on a 64-bit system.")
-  endif()
-  if("${MSVC_TOOLSET_VERSION}" STREQUAL "140")
-    # Visual Studio 2015 issues warnings and we tolerate it,  cmake -G"Visual Studio 14" ..
-    target_compile_options(simdjson-internal-flags INTERFACE /W0 /sdl)
-  else()
-    # Recent version of Visual Studio expected (2017, 2019...). Prior versions are unsupported.
-    target_compile_options(simdjson-internal-flags INTERFACE /WX /W3 /sdl /w34714) # https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-4-c4714?view=vs-2019
-  endif()
-  if(SIMDJSON_VISUAL_STUDIO_BUILD_WITH_DEBUG_INFO_FOR_PROFILING)
-    target_link_options(simdjson-flags  INTERFACE    /DEBUG )
-    target_compile_options(simdjson-flags INTERFACE  /Zi)
-  endif(SIMDJSON_VISUAL_STUDIO_BUILD_WITH_DEBUG_INFO_FOR_PROFILING)
-else(MSVC)
-  if(NOT WIN32)
-    target_compile_options(simdjson-internal-flags INTERFACE -fPIC)
-  endif()
-  target_compile_options(simdjson-internal-flags INTERFACE -Werror -Wall -Wextra -Weffc++)
-  target_compile_options(simdjson-internal-flags INTERFACE -Wsign-compare -Wshadow -Wwrite-strings -Wpointer-arith -Winit-self -Wconversion -Wno-sign-conversion)
-endif(MSVC)
-
-
-# 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)?)$"))
-  target_compile_options(simdjson-flags INTERFACE -mno-avx256-split-unaligned-load -mno-avx256-split-unaligned-store)
-endif()
-
-#
-# Optional flags
-#
-
-#
-# Implementation selection
-#
-set(SIMDJSON_ALL_IMPLEMENTATIONS "fallback;westmere;haswell;arm64;ppc64")
-
-set(SIMDJSON_IMPLEMENTATION "" CACHE STRING "Semicolon-separated list of implementations to include (${SIMDJSON_ALL_IMPLEMENTATIONS}). If this is not set, any implementations that are supported at compile time and may be selected at runtime will be included.")
-foreach(implementation ${SIMDJSON_IMPLEMENTATION})
-  if(NOT (implementation IN_LIST SIMDJSON_ALL_IMPLEMENTATIONS))
-    message(ERROR "Implementation ${implementation} not supported by simdjson. Possible implementations: ${SIMDJSON_ALL_IMPLEMENTATIONS}")
-  endif()
-endforeach(implementation)
-
-set(SIMDJSON_EXCLUDE_IMPLEMENTATION "" CACHE STRING "Semicolon-separated list of implementations to exclude (haswell/westmere/arm64/ppc64/fallback). By default, excludes any implementations that are unsupported at compile time or cannot be selected at runtime.")
-foreach(implementation ${SIMDJSON_EXCLUDE_IMPLEMENTATION})
-  if(NOT (implementation IN_LIST SIMDJSON_ALL_IMPLEMENTATIONS))
-    message(ERROR "Implementation ${implementation} not supported by simdjson. Possible implementations: ${SIMDJSON_ALL_IMPLEMENTATIONS}")
-  endif()
-endforeach(implementation)
-
-foreach(implementation ${SIMDJSON_ALL_IMPLEMENTATIONS})
-  string(TOUPPER ${implementation} implementation_upper)
-  if(implementation IN_LIST SIMDJSON_EXCLUDE_IMPLEMENTATION)
-    message(STATUS "Excluding implementation ${implementation} due to SIMDJSON_EXCLUDE_IMPLEMENTATION=${SIMDJSON_EXCLUDE_IMPLEMENTATION}")
-    target_compile_definitions(simdjson-flags INTERFACE "SIMDJSON_IMPLEMENTATION_${implementation_upper}=0")
-  elseif(implementation IN_LIST SIMDJSON_IMPLEMENTATION)
-    message(STATUS "Including implementation ${implementation} due to SIMDJSON_IMPLEMENTATION=${SIMDJSON_IMPLEMENTATION}")
-    target_compile_definitions(simdjson-flags INTERFACE "SIMDJSON_IMPLEMENTATION_${implementation_upper}=1")
-  elseif(SIMDJSON_IMPLEMENTATION)
-    message(STATUS "Excluding implementation ${implementation} due to SIMDJSON_IMPLEMENTATION=${SIMDJSON_IMPLEMENTATION}")
-    target_compile_definitions(simdjson-flags INTERFACE "SIMDJSON_IMPLEMENTATION_${implementation_upper}=0")
-  endif()
-endforeach(implementation)
-
-# TODO make it so this generates the necessary compiler flags to select the given implementation as the builtin automatically!
-option(SIMDJSON_BUILTIN_IMPLEMENTATION "Select the implementation that will be used for user code. Defaults to the most universal implementation in SIMDJSON_IMPLEMENTATION (in the order ${SIMDJSON_ALL_IMPLEMENTATIONS}) if specified; otherwise, by default the compiler will pick the best implementation that can always be selected given the compiler flags." "")
-if(SIMDJSON_BUILTIN_IMPLEMENTATION)
-  target_compile_definitions(simdjson-flags INTERFACE "SIMDJSON_BUILTIN_IMPLEMENTATION=${SIMDJSON_BUILTIN_IMPLEMENTATION}")
-else()
-  # Pick the most universal implementation out of the selected implementations (if any)
-  foreach(implementation ${SIMDJSON_ALL_IMPLEMENTATIONS})
-    if(implementation IN_LIST SIMDJSON_IMPLEMENTATION AND NOT (implementation IN_LIST SIMDJSON_EXCLUDE_IMPLEMENTATION))
-      message(STATUS "Selected implementation ${implementation} as builtin implementation based on ${SIMDJSON_IMPLEMENTATION}.")
-      target_compile_definitions(simdjson-flags INTERFACE "SIMDJSON_BUILTIN_IMPLEMENTATION=${implementation}")
-      break()
-    endif()
-  endforeach(implementation)
-endif(SIMDJSON_BUILTIN_IMPLEMENTATION)
-
-option(SIMDJSON_IMPLEMENTATION_HASWELL "Include the haswell implementation" ON)
-if(NOT SIMDJSON_IMPLEMENTATION_HASWELL)
-  message(DEPRECATION "SIMDJSON_IMPLEMENTATION_HASWELL is deprecated. Use SIMDJSON_IMPLEMENTATION=-haswell instead.")
-  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_IMPLEMENTATION_HASWELL=0)
-endif()
-option(SIMDJSON_IMPLEMENTATION_WESTMERE "Include the westmere implementation" ON)
-if(NOT SIMDJSON_IMPLEMENTATION_WESTMERE)
-  message(DEPRECATION "SIMDJSON_IMPLEMENTATION_WESTMERE is deprecated. SIMDJSON_IMPLEMENTATION=-westmere instead.")
-  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_IMPLEMENTATION_WESTMERE=0)
-endif()
-option(SIMDJSON_IMPLEMENTATION_ARM64 "Include the arm64 implementation" ON)
-if(NOT SIMDJSON_IMPLEMENTATION_ARM64)
-  message(DEPRECATION "SIMDJSON_IMPLEMENTATION_ARM64 is deprecated. Use SIMDJSON_IMPLEMENTATION=-arm64 instead.")
-  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_IMPLEMENTATION_ARM64=0)
-endif()
-option(SIMDJSON_IMPLEMENTATION_PPC64 "Include the arm64 implementation" ON)
-if(NOT SIMDJSON_IMPLEMENTATION_PPC64)
-  message(DEPRECATION "SIMDJSON_IMPLEMENTATION_PPC64 is deprecated. Use SIMDJSON_IMPLEMENTATION=-ppc64 instead.")
-  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_IMPLEMENTATION_PPC64=0)
-endif()
-option(SIMDJSON_IMPLEMENTATION_FALLBACK "Include the fallback implementation" ON)
-if(NOT SIMDJSON_IMPLEMENTATION_FALLBACK)
-  message(DEPRECATION "SIMDJSON_IMPLEMENTATION_FALLBACK is deprecated. Use SIMDJSON_IMPLEMENTATION=-fallback instead.")
-  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_IMPLEMENTATION_FALLBACK=0)
-endif()
-
-#
-# Other optional flags
-#
-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)
-  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_DEVELOPMENT_CHECKS)
-endif()
-
-option(SIMDJSON_BASH "Allow usage of bash within CMake" ON)
-
-option(SIMDJSON_EXCEPTIONS "Enable simdjson's exception-throwing interface" ON)
-if(NOT SIMDJSON_EXCEPTIONS)
-  message(STATUS "simdjson exception interface turned off. Code that does not check error codes will not compile.")
-  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_EXCEPTIONS=0)
-  if(MSVC)
-    # CMake currently /EHsc as a default flag in CMAKE_CXX_FLAGS on MSVC. Replacing this with a more general abstraction is a WIP (see https://gitlab.kitware.com/cmake/cmake/-/issues/20610)
-    # /EHs enables standard C++ stack unwinding when catching exceptions (non-structured exception handling)
-    # /EHc used in conjection with /EHs indicates that extern "C" functions never throw (terminate-on-throw)
-    # Here, we disable both with the - argument negation operator
-    string(REPLACE "/EHsc" "/EHs-c-" CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-
-    # Because we cannot change the flag above on an invidual target (yet), the definition below must similarly be added globally
-    add_definitions(-D_HAS_EXCEPTIONS=0)
-  elseif (CMAKE_COMPILER_IS_GNUCC)
-    target_link_libraries(simdjson-flags INTERFACE -fno-exceptions)
-  endif()
-endif()
-
-option(SIMDJSON_ENABLE_THREADS "Link with thread support" ON)
-if(SIMDJSON_ENABLE_THREADS)
-  set(CMAKE_THREAD_PREFER_PTHREAD TRUE)
-  set(THREADS_PREFER_PTHREAD_FLAG TRUE)
-  find_package(Threads REQUIRED)
-  target_link_libraries(simdjson-flags INTERFACE Threads::Threads)
-  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_THREADS_ENABLED=1) # This will be set in the code automatically.
-endif()
-
-option(SIMDJSON_VERBOSE_LOGGING, "Enable verbose logging for internal simdjson library development." OFF)
-if (SIMDJSON_VERBOSE_LOGGING)
-  target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_VERBOSE_LOGGING=1)
-endif()
-
-option(SIMDJSON_DISABLE_DEPRECATED_API "Disables deprecated APIs" Off)
-if (SIMDJSON_DISABLE_DEPRECATED_API)
-    target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_DISABLE_DEPRECATED_API=1)
-endif()
-
-if(SIMDJSON_USE_LIBCPP)
-  target_link_libraries(simdjson-flags INTERFACE -stdlib=libc++ -lc++abi)
-  # instead of the above line, we could have used
-  # set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -stdlib=libc++  -lc++abi")
-  # The next line is needed empirically.
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
-  # we update CMAKE_SHARED_LINKER_FLAGS, this gets updated later as well
-  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -lc++abi")
-endif(SIMDJSON_USE_LIBCPP)
-
-# prevent shared libraries from depending on Intel provided libraries
-if(${CMAKE_C_COMPILER_ID} MATCHES "Intel") # icc / icpc
-  set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -static-intel")
-endif()
-
-include (CheckSymbolExists)
-CHECK_SYMBOL_EXISTS(fork unistd.h HAVE_POSIX_FORK)
-CHECK_SYMBOL_EXISTS(wait sys/wait.h HAVE_POSIX_WAIT)
-
-install(TARGETS simdjson-flags EXPORT simdjson-config)
-
-# I do not think we want to export our internal flags!
-# install(TARGETS simdjson-internal-flags EXPORT simdjson-config)

cmake/simdjson-props.cmake

@@ -0,0 +1,48 @@
+#
+# Accumulate flags
+#
+set(simdjson_props_script "${PROJECT_BINARY_DIR}/simdjson-props.cmake")
+set(simdjson_props_content "")
+set(simdjson_props_flushed NO)
+
+function(simdjson_add_props command)
+  set(args "")
+  math(EXPR limit "${ARGC} - 1")
+  foreach(i RANGE 1 "${limit}")
+    set(value "${ARGV${i}}")
+    if(value MATCHES "^(PRIVATE|PUBLIC)$")
+      string(TOLOWER "${value}" value)
+      set(value "\${${value}}")
+    else()
+      set(value "[==[${value}]==]")
+    endif()
+    string(APPEND args " ${value}")
+  endforeach()
+
+  set(simdjson_props_flushed NO PARENT_SCOPE)
+  set(
+      simdjson_props_content
+      "${simdjson_props_content}${command}(\"\${target}\"${args})\n"
+      PARENT_SCOPE
+  )
+endfunction()
+
+macro(simdjson_flush_props)
+  if(NOT simdjson_props_flushed)
+    set(simdjson_props_flushed YES PARENT_SCOPE)
+    file(WRITE "${simdjson_props_script}" "${simdjson_props_content}")
+  endif()
+endmacro()
+
+function(simdjson_apply_props target)
+  set(private PRIVATE)
+  set(public PUBLIC)
+  get_target_property(TYPE "${target}" TYPE)
+  if(TYPE STREQUAL "INTERFACE_LIBRARY")
+    set(private INTERFACE)
+    set(public INTERFACE)
+  endif()
+
+  simdjson_flush_props()
+  include("${simdjson_props_script}")
+endfunction()

cmake/simdjson-user-cmakecache.cmake

@@ -1,24 +1,19 @@
 #
-# ${SIMDJSON_USER_CMAKECACHE} contains the *user-specified* simdjson options so you can call cmake on
+# ${USER_CMAKECACHE} contains the *user-specified* simdjson options so you can
-# another branch or repository with the same options.
+# call cmake on another branch or repository with the same options.
 #
-# Not supported on Windows at present, because the only thing that uses it is checkperf, which we
+
-# don't run on Windows.
+file(READ "${BINARY_DIR}/CMakeCache.txt" cache)
-#
+# Escape semicolons, so the lines can be safely iterated in CMake
-set(SIMDJSON_USER_CMAKECACHE ${CMAKE_CURRENT_BINARY_DIR}/.simdjson-user-CMakeCache.txt)
+string(REPLACE ";" "\\;" cache "${cache}")
-if (MSVC)
+# Turn the contents into a list
-  add_custom_command(
+string(REPLACE "\n" ";" cache "${cache}")
-    OUTPUT ${SIMDJSON_USER_CMAKECACHE}
+
-    COMMAND findstr SIMDJSON_ ${PROJECT_BINARY_DIR}/CMakeCache.txt > ${SIMDJSON_USER_CMAKECACHE}.tmp
+message(STATUS "${USER_CMAKECACHE}")
-    COMMAND findstr /v SIMDJSON_LIB_ ${SIMDJSON_USER_CMAKECACHE}.tmp > ${SIMDJSON_USER_CMAKECACHE}
+
-    VERBATIM # Makes it not do weird escaping with the command
+file(REMOVE "${USER_CMAKECACHE}")
-  )
+foreach(line IN LISTS cache)
-else()
+  if(line MATCHES "^SIMDJSON_" AND NOT line MATCHES "^SIMDJSON_LIB_")
-  add_custom_command(
+    file(APPEND "${USER_CMAKECACHE}" "${line}\n")
-    OUTPUT ${SIMDJSON_USER_CMAKECACHE}
+  endif()
-    COMMAND grep SIMDJSON_ ${PROJECT_BINARY_DIR}/CMakeCache.txt > ${SIMDJSON_USER_CMAKECACHE}.tmp
+endforeach()
-    COMMAND grep -v SIMDJSON_LIB_ ${SIMDJSON_USER_CMAKECACHE}.tmp > ${SIMDJSON_USER_CMAKECACHE}
-    VERBATIM # Makes it not do weird escaping with the command
-  )
-endif()
-add_custom_target(simdjson-user-cmakecache DEPENDS ${SIMDJSON_USER_CMAKECACHE})

fuzz/CMakeLists.txt

@@ -35,11 +35,10 @@ if(ENABLE_FUZZING)
 
   # Fuzzer build flags and libraries
   add_library(simdjson-fuzzer INTERFACE)
+  target_link_libraries(simdjson-fuzzer INTERFACE simdjson)
   if (SIMDJSON_FUZZ_LINKMAIN)
-    target_link_libraries(simdjson-fuzzer INTERFACE simdjson-source)
     target_sources(simdjson-fuzzer INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>/main.cpp)
   else ()
-    target_link_libraries(simdjson-fuzzer INTERFACE simdjson)
     target_link_libraries(simdjson-fuzzer INTERFACE ${SIMDJSON_FUZZ_LDFLAGS})
   endif ()
   target_link_libraries(simdjson-fuzzer INTERFACE simdjson-internal-flags)

include/CMakeLists.txt

@@ -1,13 +0,0 @@
-#
-# Provides the simdjson headers.
-#
-# target_link_libraries(my-project simdjson-headers) grants the headers. It does not provide the
-# source, libraries or any compiler flags.
-#
-add_library(simdjson-headers INTERFACE)
-target_compile_features(simdjson-headers INTERFACE cxx_std_11) # headers require at least C++11
-target_include_directories(simdjson-headers INTERFACE
-  $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
-  $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCDIR}>)
-
-install(TARGETS simdjson-headers EXPORT simdjson-config INCLUDES DESTINATION include)

singleheader/CMakeLists.txt

@@ -136,7 +136,6 @@ else()
   MESSAGE( STATUS "You either have an old Visual Studio or you are building a DLL, amalgamate_demo test disabled." )
 endif()
 
-install(FILES simdjson.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 # Under Windows you should not mix static and dynamic. Pick one. The following test is static.
 if(NOT SIMDJSON_LEGACY_VISUAL_STUDIO AND NOT SIMDJSON_WINDOWS_DLL)
   add_library(simdjson-singleheader STATIC "")

src/CMakeLists.txt

@@ -1,161 +0,0 @@
-#
-# For callers who intend to #include simdjson.cpp.
-#
-# target_link_libraries(my-program simdjson-include-source) gives you the header and source
-# directories. It does not specify any compiler flags.
-#
-
-add_library(simdjson-include-source INTERFACE)
-target_link_libraries(simdjson-include-source INTERFACE simdjson-headers)
-target_include_directories(simdjson-include-source INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
-# If a CMake user installs simdjson and then does...
-#   find_package(simdjson CONFIG REQUIRED)
-#   find_package(Threads REQUIRED)
-#   target_link_libraries(test PRIVATE simdjson-include-source)
-# It is not clear what it should do? Does the user get access to the src files?
-# install(TARGETS simdjson-include-source EXPORT simdjson-config)
-
-#
-# For callers who intend to compile simdjson.cpp themselves.
-#
-# target_link_libraries(my-object simdjson-source) gives you the header and source directories, plus
-# the .cpp sources. It does not specify any compiler flags.
-#
-add_library(simdjson-source INTERFACE)
-target_sources(simdjson-source INTERFACE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>/simdjson.cpp)
-target_link_libraries(simdjson-source INTERFACE simdjson-include-source)
-# Note that simdjson.cpp is *not* installed so installing simdjson-include-source is not great.
-# If a CMake user installs simdjson and then does...
-#   find_package(simdjson CONFIG REQUIRED)
-#   find_package(Threads REQUIRED)
-#   target_link_libraries(test PRIVATE simdjson-source)
-# It might fail with  Cannot find source file: simdjson.cpp
-# See issue https://github.com/simdjson/simdjson/issues/1383
-# install(TARGETS simdjson-source EXPORT simdjson-config)
-
-#
-# simdjson is the distributed library compiled with flags.
-#
-# target_link_libraries(my-object simdjson) gives you the .so or .a to link against, plus the header
-# directory. It does not specify any compiler flags, even though simdjson.so/a was compiled with
-# target_link_libraries(simdjson PRIVATE simdjson-flags).
-#
-
-if(SIMDJSON_BUILD_STATIC)
-  MESSAGE( STATUS "Building a static library." )
-  ###
-  # In the case of a static library, if you do "target_link_libraries(simdjson PRIVATE simdjson-source simdjson-internal-flags)"
-  # without also calling "install(TARGETS simdjson-source EXPORT simdjson-config)" you get an error
-  # to the effect that you are trying to install 'simdjson' which depends on 'simdjson-source' while
-  # not installing 'simdjson-source', so it fails. So we bypass entirely simdjson-source since we do
-  # not want to install them.
-  ####
-  add_library(simdjson STATIC simdjson.cpp)
-  target_include_directories(simdjson PRIVATE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>)
-else()
-  MESSAGE( STATUS "Building a dynamic library." )
-  add_library(simdjson SHARED "")
-  if(MSVC)
-    MESSAGE( STATUS "Building a Windows DLL using Visual Studio, exporting all symbols automatically." )
-    set_target_properties(simdjson PROPERTIES WINDOWS_EXPORT_ALL_SYMBOLS 1)
-    # Setting the dllexport, users of the library should never need to set SIMDJSON_BUILDING_WINDOWS_DYNAMIC_LIBRARY
-    # once the DLL is built. Note the private scope on the next line.
-    target_compile_definitions(simdjson PRIVATE SIMDJSON_BUILDING_WINDOWS_DYNAMIC_LIBRARY=1)
-    #
-    # The simdjson-flags are exported as part of the CMake install. Therefore users of
-    # the library should pick up the SIMDJSON_USING_WINDOWS_DYNAMIC_LIBRARY=1 value.
-    # It should appear in simdjson-config.cmake (an installed file) as (for example)
-    #      set_target_properties(simdjson::simdjson-flags PROPERTIES
-    #        INTERFACE_COMPILE_DEFINITIONS "SIMDJSON_THREADS_ENABLED=1"
-    #        INTERFACE_COMPILE_DEFINITIONS "SIMDJSON_USING_WINDOWS_DYNAMIC_LIBRARY=1"
-    #        INTERFACE_LINK_LIBRARIES "Threads::Threads"
-    #      )
-    #
-    target_compile_definitions(simdjson-flags INTERFACE SIMDJSON_USING_WINDOWS_DYNAMIC_LIBRARY=1)
-  endif()
-  ###
-  # Somehow, for a dynamic library, the next line is entirely fine (but not for a static one).
-  ###
-  target_link_libraries(simdjson PRIVATE simdjson-source simdjson-internal-flags)
-endif()
-target_link_libraries(simdjson PUBLIC simdjson-headers simdjson-flags) # Only expose the headers, not sources
-
-
-##
-## 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()
-
-if(NOT MSVC)
-  ## We output the library at the root of the current directory where cmake is invoked
-  ## This is handy but Visual Studio will happily ignore us
-  set_target_properties(simdjson PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR})
-  MESSAGE( STATUS "Library output directory: " ${PROJECT_BINARY_DIR})
-
-  ############
-  # Please do not delete the following, our users want version numbers. See
-  # https://github.com/simdjson/simdjson/issues/1014
-  # https://github.com/simdjson/simdjson/issues/52
-  ###########
-  set_target_properties(simdjson PROPERTIES VERSION ${SIMDJSON_LIB_VERSION}	SOVERSION ${SIMDJSON_LIB_SOVERSION})
-  ##########
-  # End of the do-not-delete message.
-  #########
-endif()
-
-#
-# Installation
-#
-install(TARGETS simdjson
-  EXPORT simdjson-config
-  ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
-  LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
-  RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
-)
-
-install(EXPORT simdjson-config
-  FILE simdjson-targets.cmake
-  NAMESPACE simdjson::
-  DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/simdjson
-)

tests/CMakeLists.txt

@@ -9,11 +9,21 @@ add_subdirectory(ondemand)
 #
 if(NOT SIMDJSON_LEGACY_VISUAL_STUDIO AND NOT SIMDJSON_WINDOWS_DLL)
   add_cpp_test(numberparsingcheck LABELS acceptance per_implementation)
-  target_link_libraries(numberparsingcheck simdjson-include-source simdjson-windows-headers)
+  simdjson_apply_props(numberparsingcheck)
+  target_link_libraries(numberparsingcheck PRIVATE simdjson-windows-headers)
   target_compile_definitions(numberparsingcheck PRIVATE NOMINMAX)
+  target_include_directories(
+      numberparsingcheck
+      PRIVATE "${PROJECT_SOURCE_DIR}/src"
+  )
   add_cpp_test(stringparsingcheck LABELS acceptance per_implementation)
-  target_link_libraries(stringparsingcheck simdjson-include-source simdjson-windows-headers)
+  simdjson_apply_props(numberparsingcheck)
+  target_link_libraries(stringparsingcheck PRIVATE simdjson-windows-headers)
   target_compile_definitions(stringparsingcheck PRIVATE NOMINMAX)
+  target_include_directories(
+      stringparsingcheck
+      PRIVATE "${PROJECT_SOURCE_DIR}/src"
+  )
 endif()
 
 # All remaining tests link with simdjson proper

tools/CMakeLists.txt

@@ -1,10 +1,13 @@
 if(TARGET cxxopts) # we only build the tools if cxxopts is available
   message(STATUS "We have cxxopts as a dependency and we are buiding the tools (e.g., json2json).")
-  link_libraries(simdjson simdjson-internal-flags simdjson-windows-headers cxxopts)
+  foreach(tool IN ITEMS json2json jsonstats jsonpointer minify)
-  add_executable(json2json json2json.cpp)
+    add_executable("${tool}" "${tool}.cpp")
-  add_executable(jsonstats jsonstats.cpp)
+    simdjson_apply_props("${tool}")
-  add_executable(jsonpointer jsonpointer.cpp)
+    target_link_libraries(
-  add_executable(minify minify.cpp)
+        "${tool}" PRIVATE
+        simdjson simdjson-internal-flags simdjson-windows-headers cxxopts
+    )
+  endforeach()
 else()
   message(STATUS "We are missing cxxopts as a dependency so the tools (e.g., json2json) are omitted.")
-endif()
+endif()

tools/release.py

@@ -145,11 +145,8 @@ if(atleastminor):
     sonumber += 1
 
 for line in fileinput.input(cmakefile, inplace=1, backup='.bak'):
-    line = re.sub('SIMDJSON_SEMANTIC_VERSION "\d+\.\d+\.\d+','SIMDJSON_SEMANTIC_VERSION "'+newversionstring, line.rstrip())
+    line = re.sub('    VERSION \d+\.\d+\.\d+','    VERSION '+newmajorversionstring+'.'+mewminorversionstring+'.'+newrevversionstring, line)
     line = re.sub('SIMDJSON_LIB_VERSION "\d+','SIMDJSON_LIB_VERSION "'+str(sonumber), line)
-    line = re.sub('set\(PROJECT_VERSION_MAJOR \d+','set(PROJECT_VERSION_MAJOR '+newmajorversionstring, line)
-    line = re.sub('set\(PROJECT_VERSION_MINOR \d+','set(PROJECT_VERSION_MINOR '+mewminorversionstring, line)
-    line = re.sub('set\(PROJECT_VERSION_PATCH \d+','set(PROJECT_VERSION_PATCH '+newrevversionstring, line)
     line = re.sub('set\(SIMDJSON_LIB_SOVERSION \"\d+\"','set(SIMDJSON_LIB_SOVERSION \"'+str(sonumber)+'\"', line)
     print(line)