mdbx-build: start using CMake (incomplete; no properly installation for now).

.gitignore

@@ -12,15 +12,11 @@
 .idea
 .le.ini
 .vs/
-Win32/
-build-*
 cmake-build-*
+@*
 core
 example
 libmdbx.creator.user
-mdbx-dll.VC.VC.opendb
-mdbx-dll.VC.db
-mdbx-dll.vcxproj.filters
 mdbx_chk
 mdbx_copy
 mdbx_dump
@@ -28,11 +24,9 @@ mdbx_load
 mdbx_stat
 mdbx_test
 test.log
-test/test.vcxproj.user
 test/tmp.db
 test/tmp.db-lck
 tmp.db
 tmp.db-lck
 valgrind.*
-x64/
+version.c
-x86/

.travis.yml

@@ -11,6 +11,20 @@ os:
 
 script: if [ "${COVERITY_SCAN_BRANCH}" != 1 ]; then make all check; fi
 
+script: >
+  if [ "${COVERITY_SCAN_BRANCH}" != 1 ]; then
+    git fetch --unshallow --tags --prune &&
+    git submodule foreach --recursive git fetch --unshallow --tags --prune &&
+    (if which clang-format-6.0 > /dev/null && make reformat && [[ -n $(git diff) ]];
+      then
+        echo "You must run 'make reformat' before submitting a pull request";
+        echo "";
+        git diff;
+        exit -1;
+      fi) &&
+    make --keep-going all && MALLOC_CHECK_=7 MALLOC_PERTURB_=42 make --keep-going check
+  fi
+
 env:
   global:
    - secure: "M+W+heGGyRQJoBq2W0uqWVrpL4KBXmL0MFL7FSs7f9vmAaDyEgziUXeZRj3GOKzW4kTef3LpIeiu9SmvqSMoQivGGiomZShqPVl045o/OUgRCAT7Al1RLzEZ0efSHpIPf0PZ6byEf6GR2ML76OfuL6JxTVdnz8iVyO2sgLE1HbX1VeB+wgd/jfMeOBhCCXskfK6MLyZihfMYsiYZYSaV98ZDhDLSlzuuRIgzb0bMi8aL6AErs0WLW0NelRBeHkKPYfAUc85pdQHscgrJw6Rh/zT6+8BQ/q5f4IgWhiu4xoRg3Ngl7SNoedRQh93ADM3UG2iGl6HDFpVORaXcFWKAtuYY+kHQ0HB84BRYpQmeBuXNpltsfxQ3d1Q3u0RlE45zRvmr2+X1mFnkcNUAWISLPbsOUlriDQM8irGwRpho77/uYnRC00bJsHW//s6+uPf9zrAw1nI4f0y3PAWukGF/xs6HAI3FZPsuSSnx18Tj3Opgbc9Spop+V3hkhdiJoPGpNKTkFX4ZRXfkPgoRVJmtp4PpbpH0Ps/mCriKjMEfGGi0HcVCi0pEGLXiecdqJ5KPg5+22zNycEujQBJcNTKd9shN+R3glrbmhAxTEzGdGwxXXJ2ybwJ2PWJLMYZ7g98nLyX+uQPaA3BlsbYJHNeS5283/9pJsd9DzfHKsN2nFSc="

CMakeLists.txt

@@ -0,0 +1,273 @@
+##
+##  Copyright 2019 Leonid Yuriev <leo@yuriev.ru>
+##  and other libmdbx authors: please see AUTHORS file.
+##  All rights reserved.
+##
+##  Redistribution and use in source and binary forms, with or without
+##  modification, are permitted only as authorized by the OpenLDAP
+##  Public License.
+##
+##  A copy of this license is available in the file LICENSE in the
+##  top-level directory of the distribution or, alternatively, at
+##  <http://www.OpenLDAP.org/license.html>.
+##
+
+##
+##  libmdbx = { Revised and extended descendant of Symas LMDB. }
+##  Please see README.md at https://github.com/leo-yuriev/libmdbx
+##
+##  Libmdbx is superior to LMDB in terms of features and reliability,
+##  not inferior in performance. libmdbx works on Linux, FreeBSD, MacOS X
+##  and other systems compliant with POSIX.1-2008, but also support Windows
+##  as a complementary platform.
+##
+##  The next version is under active non-public development and will be
+##  released as MithrilDB and libmithrildb for libraries & packages.
+##  Admittedly mythical Mithril is resembling silver but being stronger and
+##  lighter than steel. Therefore MithrilDB is rightly relevant name.
+##
+##  MithrilDB will be radically different from libmdbx by the new database
+##  format and API based on C++17, as well as the Apache 2.0 License.
+##  The goal of this revolution is to provide a clearer and robust API,
+##  add more features and new valuable properties of database.
+##
+##  The Future will (be) Positive. Всё будет хорошо.
+##
+
+cmake_minimum_required(VERSION 3.8.2)
+cmake_policy(PUSH)
+cmake_policy(VERSION 3.8.2)
+if(NOT CMAKE_VERSION VERSION_LESS 3.12)
+  cmake_policy(SET CMP0075 NEW)
+endif()
+if(NOT CMAKE_VERSION VERSION_LESS 3.9)
+  cmake_policy(SET CMP0069 NEW)
+  include(CheckIPOSupported)
+  check_ipo_supported(RESULT CMAKE_INTERPROCEDURAL_OPTIMIZATION_AVAILABLE)
+else()
+  set(CMAKE_INTERPROCEDURAL_OPTIMIZATION_AVAILABLE FALSE)
+endif()
+
+if(DEFINED PROJECT_NAME)
+  set(SUBPROJECT ON)
+  if(NOT DEFINED BUILD_TESTING)
+    set(BUILD_TESTING OFF)
+  endif()
+else()
+  set(SUBPROJECT OFF)
+  project(libmdbx C CXX)
+  if(NOT DEFINED BUILD_TESTING)
+    set(BUILD_TESTING ON)
+  endif()
+endif()
+
+# only for compatibility testing
+# set(CMAKE_CXX_STANDARD 14)
+
+if(NOT "$ENV{TEAMCITY_PROCESS_FLOW_ID}" STREQUAL "")
+  set(CI TEAMCITY)
+  message(STATUS "TeamCity CI")
+elseif(NOT "$ENV{TRAVIS}" STREQUAL "")
+  set(CI TRAVIS)
+  message(STATUS "Travis CI")
+elseif(NOT "$ENV{CIRCLECI}" STREQUAL "")
+  set(CI CIRCLE)
+  message(STATUS "Circle CI")
+elseif(NOT "$ENV{APPVEYOR}" STREQUAL "")
+  set(CI APPVEYOR)
+  message(STATUS "AppVeyor CI")
+elseif(NOT "$ENV{CI}" STREQUAL "")
+  set(CI "$ENV{CI}")
+  message(STATUS "Other CI (${CI})")
+else()
+  message(STATUS "Assume No any CI environment")
+  unset(CI)
+endif()
+
+include(CheckLibraryExists)
+include(CheckIncludeFiles)
+include(CheckCCompilerFlag)
+include(CheckSymbolExists)
+include(CheckCSourceRuns)
+include(CheckCXXSourceRuns)
+include(CheckCSourceCompiles)
+include(CheckCXXSourceCompiles)
+include(TestBigEndian)
+include(CheckFunctionExists)
+include(FindPackageMessage)
+include(CheckStructHasMember)
+include(CMakeDependentOption)
+include(GNUInstallDirs)
+
+if(CMAKE_C_COMPILER_ID STREQUAL "MSVC" AND MSVC_VERSION LESS 1900)
+  message(SEND_ERROR "MSVC compiler ${MSVC_VERSION} is too old for building MDBX."
+    " At least 'Microsoft Visual Studio 2015' is required.")
+endif()
+
+# Set default build type to Release. This is to ease a User's life.
+if(NOT CMAKE_BUILD_TYPE)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING
+    "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel."
+    FORCE)
+endif()
+string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_UPPERCASE)
+
+include(cmake/utils.cmake)
+include(cmake/compiler.cmake)
+include(cmake/profile.cmake)
+option(PROVIDE_VERSIONINFO "Provide library's version information." ON)
+
+find_program(ECHO echo)
+find_program(CAT cat)
+find_program(GIT git)
+find_program(LD ld)
+
+# CHECK_INCLUDE_FILES(unistd.h HAVE_UNISTD_H)
+# CHECK_INCLUDE_FILES(sys/uio.h HAVE_SYS_UIO_H)
+# CHECK_INCLUDE_FILES(sys/stat.h HAVE_SYS_STAT_H)
+
+CHECK_FUNCTION_EXISTS(pow NOT_NEED_LIBM)
+if(NOT_NEED_LIBM)
+  set(LIB_MATH "")
+else()
+  set(CMAKE_REQUIRED_LIBRARIES m)
+  CHECK_FUNCTION_EXISTS(pow HAVE_LIBM)
+  if(HAVE_LIBM)
+    set(LIB_MATH m)
+  else()
+    message(FATAL_ERROR "No libm found for math support")
+  endif()
+endif()
+
+find_package(Threads REQUIRED)
+
+if(NOT SUBPROJECT)
+  option(CMAKE_POSITION_INDEPENDENT_CODE "Generate position independed (PIC)." ON)
+  option(BUILD_SHARED_LIBS "Build shared libraries (DLLs)." ON)
+  if (CC_HAS_ARCH_NATIVE)
+    option(BUILD_FOR_NATIVE_CPU "Generate code for the compiling machine CPU." OFF)
+  endif()
+
+  if(CMAKE_CONFIGURATION_TYPES OR NOT CMAKE_BUILD_TYPE_UPPERCASE STREQUAL "DEBUG")
+    set(INTERPROCEDURAL_OPTIMIZATION_DEFAULT ON)
+  else()
+    set(INTERPROCEDURAL_OPTIMIZATION_DEFAULT OFF)
+  endif()
+
+  if(CMAKE_INTERPROCEDURAL_OPTIMIZATION_AVAILABLE
+      OR GCC_LTO_AVAILABLE OR MSVC_LTO_AVAILABLE OR CLANG_LTO_AVAILABLE)
+    option(INTERPROCEDURAL_OPTIMIZATION "Enable interprocedural/LTO optimization." ${INTERPROCEDURAL_OPTIMIZATION_DEFAULT})
+  endif()
+
+  if(INTERPROCEDURAL_OPTIMIZATION)
+    if(GCC_LTO_AVAILABLE)
+      set(LTO_ENABLED TRUE)
+      set(CMAKE_AR ${CMAKE_GCC_AR} CACHE PATH "Path to ar program with LTO-plugin" FORCE)
+      set(CMAKE_NM ${CMAKE_GCC_NM} CACHE PATH "Path to nm program with LTO-plugin" FORCE)
+      set(CMAKE_RANLIB ${CMAKE_GCC_RANLIB} CACHE PATH "Path to ranlib program with LTO-plugin" FORCE)
+      message(STATUS "MDBX indulge Link-Time Optimization by GCC")
+    elseif(CLANG_LTO_AVAILABLE)
+      set(LTO_ENABLED TRUE)
+      set(CMAKE_AR ${CMAKE_CLANG_AR} CACHE PATH "Path to ar program with LTO-plugin" FORCE)
+      set(CMAKE_NM ${CMAKE_CLANG_NM} CACHE PATH "Path to nm program with LTO-plugin" FORCE)
+      set(CMAKE_RANLIB ${CMAKE_CLANG_RANLIB} CACHE PATH "Path to ranlib program with LTO-plugin" FORCE)
+      message(STATUS "MDBX indulge Link-Time Optimization by CLANG")
+    elseif(MSVC_LTO_AVAILABLE)
+      set(LTO_ENABLED TRUE)
+      message(STATUS "MDBX indulge Link-Time Optimization by MSVC")
+    elseif(CMAKE_INTERPROCEDURAL_OPTIMIZATION_AVAILABLE)
+      message(STATUS "MDBX indulge Interprocedural Optimization by CMake")
+      set(CMAKE_INTERPROCEDURAL_OPTIMIZATION TRUE)
+      set(LTO_ENABLED TRUE)
+    else()
+      message(WARNING "Unable to engage interprocedural/LTO optimization.")
+    endif()
+  else()
+    set(CMAKE_INTERPROCEDURAL_OPTIMIZATION FALSE)
+    set(LTO_ENABLED FALSE)
+  endif()
+
+  find_program(VALGRIND valgrind)
+  if(VALGRIND)
+    # LY: cmake is ugly and nasty.
+    #      - therefore memcheck-options should be defined before including ctest;
+    #      - otherwise ctest may ignore it.
+    set(MEMORYCHECK_SUPPRESSIONS_FILE
+      "${PROJECT_SOURCE_DIR}/test/valgrind_suppress.txt"
+      CACHE FILEPATH "Suppressions file for Valgrind" FORCE)
+    set(MEMORYCHECK_COMMAND_OPTIONS
+      "--trace-children=yes --leak-check=full --track-origins=yes --error-exitcode=42 --error-markers=@ --errors-for-leak-kinds=definite --fair-sched=yes --suppressions=${MEMORYCHECK_SUPPRESSIONS_FILE}"
+      CACHE STRING "Valgrind options" FORCE)
+    set(VALGRIND_COMMAND_OPTIONS "${MEMORYCHECK_COMMAND_OPTIONS}" CACHE STRING "Valgrind options" FORCE)
+  endif()
+
+  #
+  # Enable 'make tags' target.
+  find_program(CTAGS ctags)
+  if(CTAGS)
+    add_custom_target(tags COMMAND ${CTAGS} -R -f tags
+      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+    add_custom_target(ctags DEPENDS tags)
+  endif(CTAGS)
+
+  #
+  # Enable 'make reformat' target.
+  find_program(CLANG_FORMAT
+    NAMES clang-format-6.0 clang-format-5.0 clang-format-4.0
+    clang-format-3.9 clang-format-3.8 clang-format-3.7 clang-format)
+  if(CLANG_FORMAT AND UNIX)
+    add_custom_target(reformat
+      VERBATIM
+      COMMAND
+      git ls-files |
+      grep -E \\.\(c|cxx|cc|cpp|h|hxx|hpp\)\(\\.in\)?\$ |
+      xargs ${CLANG_FORMAT} -i --style=file
+      WORKING_DIRECTORY ${CMAKE_SOURCE_DIR})
+  endif()
+
+  if(NOT "${PROJECT_BINARY_DIR}" STREQUAL "${PROJECT_SOURCE_DIR}")
+    add_custom_target(distclean)
+    add_custom_command(TARGET distclean
+      COMMAND ${CMAKE_COMMAND} -E remove_directory "${PROJECT_BINARY_DIR}"
+      COMMENT "Removing the build directory and its content")
+  elseif(IS_DIRECTORY .git AND GIT)
+    add_custom_target(distclean)
+    add_custom_command(TARGET distclean
+      WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
+      COMMAND ${GIT} submodule foreach --recursive git clean -f -X -d
+      COMMAND ${GIT} clean -f -X -d
+      COMMENT "Removing all build files from the source directory")
+  endif()
+
+  setup_compile_flags()
+endif(NOT SUBPROJECT)
+
+option(MDBX_ENABLE_TESTS "Build MDBX tests." ${BUILD_TESTING})
+
+################################################################################
+
+if(PROVIDE_VERSIONINFO)
+  set(HAVE_MDBX_VERSIONINFO TRUE)
+else()
+  set(HAVE_MDBX_VERSIONINFO FALSE)
+endif()
+
+set(LIBMDBX_CONFIG_H "${CMAKE_CURRENT_BINARY_DIR}/mdbx-build-config.h")
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/src/elements/config.h.in ${LIBMDBX_CONFIG_H})
+
+add_subdirectory(src)
+if(MDBX_ENABLE_TESTS)
+  add_subdirectory(test)
+endif()
+
+if(HAVE_MDBX_VERSIONINFO)
+  set(PACKAGE "libmdbx")
+  set(CPACK_PACKAGE_VERSION_MAJOR ${MDBX_VERSION_MAJOR})
+  set(CPACK_PACKAGE_VERSION_MINOR ${MDBX_VERSION_MINOR})
+  set(CPACK_PACKAGE_VERSION_PATCH ${MDBX_VERSION_RELEASE})
+  set(CPACK_PACKAGE_VERSION_COMMIT ${MDBX_VERSION_REVISION})
+  set(PACKAGE_VERSION "${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}.${CPACK_PACKAGE_VERSION_COMMIT}")
+  message(STATUS "libmdbx package version is ${PACKAGE_VERSION}")
+endif()
+
+cmake_policy(POP)

GNUmakefile

@@ -1,15 +1,11 @@
-# GNU Makefile for libmdbx, https://abf.io/erthink/libmdbx
+# This makefile is for GNU Make, and nowadays provided
-
+# just for compatibility and preservation of traditions.
-########################################################################
+# Please use CMake in case of any difficulties or problems.
-# Configuration. The compiler options must enable threaded compilation.
-#
-# Preprocessor macros (for XCFLAGS) of interest...
-# Note that the defaults should already be correct for most
-# platforms; you should not need to change any of these.
-# Read their descriptions in mdb.c if you do. There may be
-# other macros of interest. You should read mdb.c
-# before changing any of them.
 #
+# Preprocessor macros (for MDBX_OPTIONS) of interest...
+# Note that the defaults should already be correct for most platforms;
+# you should not need to change any of these. Read their descriptions
+# in README and source code if you do. There may be other macros of interest.
 
 # install sandbox
 SANDBOX	?=
@@ -24,10 +20,9 @@ suffix	?=
 CC	?= gcc
 CXX	?= g++
 LD	?= ld
-CFLAGS	?= -O2 -g3 -Wall -Werror -Wextra -ffunction-sections -fPIC -fvisibility=hidden
+MDBX_OPTIONS ?= -D_GNU_SOURCE=1 -DNDEBUG=1 -DLIBMDBX_EXPORTS=1
+CFLAGS	?= -O2 -g3 -Wall -Werror -Wextra -ffunction-sections -fPIC -fvisibility=hidden -std=gnu11 -pthread
 
-XCFLAGS	?= -DNDEBUG=1 -DLIBMDBX_EXPORTS=1
-CFLAGS	+= -D_GNU_SOURCE=1 -std=gnu11 -pthread $(XCFLAGS)
 CXXFLAGS = -std=c++11 $(filter-out -std=gnu11,$(CFLAGS))
 TESTDB	?= $(shell [ -d /dev/shm ] && echo /dev/shm || echo /tmp)/mdbx-test.db
 TESTLOG ?= $(shell [ -d /dev/shm ] && echo /dev/shm || echo /tmp)/mdbx-test.log
@@ -125,24 +120,45 @@ check-fault:	all
 	rm -f $(TESTDB) $(TESTLOG) && (set -o pipefail; ./mdbx_test --pathname=$(TESTDB) --inject-writefault=42 --dump-config --dont-cleanup-after basic | tee -a $(TESTLOG) | tail -n 42) \
 	; ./mdbx_chk -vvnw $(TESTDB) && ([ ! -e $(TESTDB)-copy ] || ./mdbx_chk -vvn $(TESTDB)-copy)
 
+MDBX_VERSION_GIT = ${shell set -o pipefail; git describe --tags | sed -n 's|^v*\([0-9]\{1,\}\.[0-9]\{1,\}\.[0-9]\{1,\}\)\(.*\)|\1|p' || echo 'Please fetch tags and/or install latest git version'}
+version.c: src/elements/version.c.in $(lastword $(MAKEFILE_LIST)) .git/HEAD .git/index .git/refs/tags
+	sed \
+	        -e "s|@MDBX_BUILD_TIMESTAMP@|$(shell date +%Y-%m-%dT%H:%M:%S%z)|" \
+		-e "s|@MDBX_GIT_TIMESTAMP@|$(shell git show --no-patch --format=%cI HEAD || echo 'Please install latest get version')|" \
+		-e "s|@MDBX_GIT_TREE@|$(shell git show --no-patch --format=%T HEAD || echo 'Please install latest get version')|" \
+		-e "s|@MDBX_GIT_COMMIT@|$(shell git show --no-patch --format=%H HEAD || echo 'Please install latest get version')|" \
+		-e "s|@MDBX_GIT_DESCRIBE@|$(shell git describe --tags --long --dirty=-dirty || echo 'Please fetch tags and/or install latest git version')|" \
+		-e "s|\$${MDBX_VERSION_MAJOR}|$(shell echo '$(MDBX_VERSION_GIT)' | cut -d . -f 1)|" \
+		-e "s|\$${MDBX_VERSION_MINOR}|$(shell echo '$(MDBX_VERSION_GIT)' | cut -d . -f 2)|" \
+		-e "s|\$${MDBX_VERSION_RELEASE}|$(shell echo '$(MDBX_VERSION_GIT)' | cut -d . -f 3)|" \
+		-e "s|\$${MDBX_VERSION_REVISION}|$(shell git rev-list --count --no-merges HEAD || echo 'Please fetch tags and/or install latest git version')|" \
+		-e "s|@MDBX_OPTIONS@|$(MDBX_OPTIONS)|" \
+		-e "s|\$${MDBX_COMPILE_FLAGS}|\"$(CFLAGS) $(LDFLAGS)\"|" \
+		-e "s|@MDBX_BUILD_COMPILER@|$(shell set -o pipefail; $(CC) --version | head -1 || echo 'Please use GCC or CLANG compatible compiler')|" \
+		-e "s|\$${MDBX_BUILD_TARGET}|\"$(shell set -o pipefail; LC_ALL=C $(CC) -v 2>&1 | grep -i '^Target:' | cut -d ' ' -f 2- || echo 'Please use GCC or CLANG compatible compiler')\"|" \
+	src/elements/version.c.in > $@
+
+version.o: version.c $(lastword $(MAKEFILE_LIST))
+	$(CC) $(CFLAGS) $(MDBX_OPTIONS) -I./src -c version.c -o $@
+
 libmdbx.o: src/alloy.c $(ALLOY_DEPS) $(lastword $(MAKEFILE_LIST))
-	$(CC) $(CFLAGS) -c src/alloy.c -o $@
+	$(CC) $(CFLAGS) $(MDBX_OPTIONS) -c src/alloy.c -o $@
 
 define test-rule
 $(patsubst %.cc,%.o,$(1)): $(1) $(TEST_INC) mdbx.h $(lastword $(MAKEFILE_LIST))
-	$(CXX) $(CXXFLAGS) -c $(1) -o $$@
+	$(CXX) $(CXXFLAGS) $(MDBX_OPTIONS) -c $(1) -o $$@
 
 endef
 $(foreach file,$(TEST_SRC),$(eval $(call test-rule,$(file))))
 
-libmdbx.a: libmdbx.o
+libmdbx.a: libmdbx.o version.o
 	$(AR) rs $@ $?
 
-libmdbx.$(SO_SUFFIX): libmdbx.o
+libmdbx.$(SO_SUFFIX): libmdbx.o version.o
 	$(CC) $(CFLAGS) $^ -pthread -shared $(LDFLAGS) -o $@
 
 mdbx_%:	src/tools/mdbx_%.c libmdbx.a
-	$(CC) $(CFLAGS) $^ $(EXE_LDFLAGS) -o $@
+	$(CC) $(CFLAGS) $(MDBX_OPTIONS) $^ $(EXE_LDFLAGS) -o $@
 
 mdbx_test: $(TEST_OBJ) libmdbx.$(SO_SUFFIX)
 	$(CXX) $(CXXFLAGS) $(TEST_OBJ) -Wl,-rpath . -L . -l mdbx $(EXE_LDFLAGS) -o $@

appveyor.yml

@@ -2,12 +2,16 @@ version: 0.3.2.{build}
 
 environment:
   matrix:
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      CMAKE_GENERATOR: Visual Studio 16 2019
+      TOOLSET: 142
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      TOOLSET: v141
+      CMAKE_GENERATOR: Visual Studio 15 2017
+      TOOLSET: 141
 #    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
-#      TOOLSET: v140
+#      TOOLSET: 140
 #    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
-#      TOOLSET: v120
+#      TOOLSET: 120
 
 branches:
   except:
@@ -18,34 +22,56 @@ configuration:
 - Release
 
 platform:
-- x86
+- Win32
 - x64
-#- ARM
+
+before_build:
+- git submodule sync
+- git fetch --tags --prune
+- git submodule update --init --recursive
+- git submodule foreach --recursive git fetch --tags --prune
+- cmake --version
 
 build_script:
-- ps: >
+- ps: |
-    msbuild "C:\projects\libmdbx\mdbx.sln" /verbosity:minimal
+    Write-Output "*******************************************************************************"
-    /logger:"C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
+    Write-Output "Configuration: $env:CONFIGURATION"
-    /property:PlatformToolset=$env:TOOLSET
+    Write-Output "Platform: $env:PLATFORM"
-    /property:Configuration=$env:CONFIGURATION
+    Write-Output "Toolchain: $env:CMAKE_GENERATOR v$env:TOOLSET"
-    /property:Platform=$env:PLATFORM
+    Write-Output "*******************************************************************************"
+
+    md _build -Force | Out-Null
+    cd _build
+
+    $generator = $env:CMAKE_GENERATOR
+    if ($env:TOOLSET -lt 142) {
+        if ($env:PLATFORM -eq "x64") {
+            $generator = "$generator Win64"
+        }
+        & cmake -G "$generator" -DCMAKE_CONFIGURATION_TYPES="Debug;Release" ..
+    } else {
+        & cmake -G "$generator" -A $env:PLATFORM -DCMAKE_CONFIGURATION_TYPES="Debug;Release" ..
+    }
+    if ($LastExitCode -ne 0) {
+        throw "Exec: $ErrorMessage"
+    }
+    Write-Output "*******************************************************************************"
+
+    & cmake --build . --config $env:CONFIGURATION
+    if ($LastExitCode -ne 0) {
+        throw "Exec: $ErrorMessage"
+    }
+    Write-Output "*******************************************************************************"
 
 test_script:
 - ps: |
-    if (($env:PLATFORM -eq "x86") -and (Test-Path "C:\projects\libmdbx\Win32\$env:CONFIGURATION\mdbx_test.exe" -PathType Leaf)) {
+    if (($env:PLATFORM -ne "ARM") -and ($env:PLATFORM -ne "ARM64")) {
-      $mdbx_test = "C:\projects\libmdbx\Win32\$env:CONFIGURATION\mdbx_test.exe"
+        & test\mdbx_test.exe --pathname=test.db --dont-cleanup-after basic | Tee-Object -file test.log | Select-Object -last 42
-      $mdbx_chk = "C:\projects\libmdbx\Win32\$env:CONFIGURATION\mdbx_chk.exe"
+        if ($LastExitCode -ne 0) {
-    } elseif (($env:PLATFORM -ne "ARM") -and ($env:PLATFORM -ne "ARM64")) {
+            throw "Exec: $ErrorMessage"
-      $mdbx_test = "C:\projects\libmdbx\$env:PLATFORM\$env:CONFIGURATION\mdbx_test.exe"
+        } else {
-      $mdbx_chk = "C:\projects\libmdbx\$env:PLATFORM\$env:CONFIGURATION\mdbx_chk.exe"
+            & src\tools\mdbx_chk.exe -nvv test.db | Tee-Object -file chk.log | Select-Object -last 42
-    } else {
+        }
-      $mdbx_test = ""
-      $mdbx_chk = ""
-    }
-
-    if ($mdbx_test -ne "") {
-        & "$mdbx_test" --pathname=test.db --dont-cleanup-after basic | Tee-Object -file test.log | Select-Object -last 42
-        & "$mdbx_chk" -nvv test.db | Tee-Object -file chk.log | Select-Object -last 42
     }
 
 on_failure:

cmake/compiler.cmake

@@ -0,0 +1,660 @@
+##  Copyright (c) 2012-2019 Leonid Yuriev <leo@yuriev.ru>.
+##
+##  Licensed under the Apache License, Version 2.0 (the "License");
+##  you may not use this file except in compliance with the License.
+##  You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+##  Unless required by applicable law or agreed to in writing, software
+##  distributed under the License is distributed on an "AS IS" BASIS,
+##  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+##  See the License for the specific language governing permissions and
+##  limitations under the License.
+##
+
+cmake_minimum_required(VERSION 3.8.2)
+cmake_policy(PUSH)
+cmake_policy(VERSION 3.8.2)
+
+if (CMAKE_VERSION MATCHES ".*MSVC.*")
+  message(FATAL_ERROR "CMake from MSVC kit is unfit! "
+    "Please use the original CMake from https://cmake.org/download/")
+endif()
+
+if (NOT (CMAKE_C_COMPILER_LOADED OR CMAKE_CXX_COMPILER_LOADED))
+  message(FATAL_ERROR "This module required C or C++ to be enabled")
+endif()
+
+include(CMakeDependentOption)
+
+if(CMAKE_CXX_COMPILER_LOADED)
+  include(CheckCXXSourceRuns)
+  include(CheckCXXSourceCompiles)
+  include(CheckCXXCompilerFlag)
+endif()
+if(CMAKE_C_COMPILER_LOADED)
+  include(CheckCSourceRuns)
+  include(CheckCSourceCompiles)
+  include(CheckCCompilerFlag)
+endif()
+
+# Check if the same compile family is used for both C and CXX
+if(CMAKE_C_COMPILER_LOADED AND CMAKE_CXX_COMPILER_LOADED AND
+    NOT (CMAKE_C_COMPILER_ID STREQUAL CMAKE_CXX_COMPILER_ID))
+  message(WARNING "CMAKE_C_COMPILER_ID (${CMAKE_C_COMPILER_ID}) is different "
+    "from CMAKE_CXX_COMPILER_ID (${CMAKE_CXX_COMPILER_ID}). "
+    "The final binary may be unusable.")
+endif()
+
+if(CMAKE_CXX_COMPILER_LOADED)
+  set(CMAKE_PRIMARY_LANG "CXX")
+else()
+  set(CMAKE_PRIMARY_LANG "C")
+endif()
+
+macro(check_compiler_flag flag variable)
+  if(CMAKE_CXX_COMPILER_LOADED)
+    check_cxx_compiler_flag(${flag} ${variable})
+  else()
+    check_c_compiler_flag(${flag} ${variable})
+  endif()
+endmacro(check_compiler_flag)
+
+# We support building with Clang and gcc. First check
+# what we're using for build.
+if(CMAKE_C_COMPILER_LOADED AND CMAKE_C_COMPILER_ID STREQUAL "Clang")
+  set(CMAKE_COMPILER_IS_CLANG  ON)
+  set(CMAKE_COMPILER_IS_GNUCC  OFF)
+endif()
+if(CMAKE_CXX_COMPILER_LOADED AND CMAKE_CXx_COMPILER_ID STREQUAL "Clang")
+  set(CMAKE_COMPILER_IS_CLANG  ON)
+  set(CMAKE_COMPILER_IS_GNUCXX OFF)
+endif()
+
+# Hard coding the compiler version is ugly from cmake POV, but
+# at least gives user a friendly error message. The most critical
+# demand for C++ compiler is support of C++11 lambdas, added
+# only in version 4.5 https://gcc.gnu.org/projects/cxx0x.html
+if(CMAKE_COMPILER_IS_GNUCC)
+  if(CMAKE_C_COMPILER_VERSION VERSION_LESS 4.5)
+    message(FATAL_ERROR "
+      Your GCC version is ${CMAKE_C_COMPILER_VERSION}, please update")
+  endif()
+endif()
+if(CMAKE_COMPILER_IS_GNUCXX)
+  if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4.5)
+    message(FATAL_ERROR "
+      Your G++ version is ${CMAKE_CXX_COMPILER_VERSION}, please update")
+  endif()
+endif()
+
+if(CMAKE_C_COMPILER_LOADED)
+  # Check for Elbrus lcc
+  execute_process(COMMAND ${CMAKE_C_COMPILER} --version
+    OUTPUT_VARIABLE tmp_lcc_probe_version
+    RESULT_VARIABLE tmp_lcc_probe_result ERROR_QUIET)
+  if(tmp_lcc_probe_result EQUAL 0)
+    string(FIND "${tmp_lcc_probe_version}" "lcc:" tmp_lcc_marker)
+    string(FIND "${tmp_lcc_probe_version}" ":e2k-" tmp_e2k_marker)
+    if(tmp_lcc_marker GREATER -1 AND tmp_e2k_marker GREATER tmp_lcc_marker)
+      execute_process(COMMAND ${CMAKE_C_COMPILER} -print-version
+        OUTPUT_VARIABLE CMAKE_C_COMPILER_VERSION
+        RESULT_VARIABLE tmp_lcc_probe_result)
+      set(CMAKE_COMPILER_IS_ELBRUSC ON)
+      set(CMAKE_C_COMPILER_ID "Elbrus")
+    else()
+      set(CMAKE_COMPILER_IS_ELBRUSC OFF)
+    endif()
+    unset(tmp_lcc_marker)
+    unset(tmp_e2k_marker)
+  endif()
+  unset(tmp_lcc_probe_version)
+  unset(tmp_lcc_probe_result)
+endif()
+
+if(CMAKE_CXX_COMPILER_LOADED)
+  # Check for Elbrus l++
+  execute_process(COMMAND ${CMAKE_CXX_COMPILER} --version
+    OUTPUT_VARIABLE tmp_lxx_probe_version
+    RESULT_VARIABLE tmp_lxx_probe_result ERROR_QUIET)
+  if(tmp_lxx_probe_result EQUAL 0)
+    string(FIND "${tmp_lxx_probe_version}" "lcc:" tmp_lcc_marker)
+    string(FIND "${tmp_lxx_probe_version}" ":e2k-" tmp_e2k_marker)
+    if(tmp_lcc_marker GREATER -1 AND tmp_e2k_marker GREATER tmp_lcc_marker)
+      execute_process(COMMAND ${CMAKE_CXX_COMPILER} -print-version
+        OUTPUT_VARIABLE CMAKE_CXX_COMPILER_VERSION
+        RESULT_VARIABLE tmp_lxx_probe_result)
+      set(CMAKE_COMPILER_IS_ELBRUSCXX ON)
+      set(CMAKE_CXX_COMPILER_ID "Elbrus")
+    else()
+      set(CMAKE_COMPILER_IS_ELBRUSCXX OFF)
+    endif()
+    unset(tmp_lcc_marker)
+    unset(tmp_e2k_marker)
+  endif()
+  unset(tmp_lxx_probe_version)
+  unset(tmp_lxx_probe_result)
+endif()
+
+if(CMAKE_CL_64)
+  set(MSVC64 1)
+endif()
+if(WIN32 AND CMAKE_COMPILER_IS_GNU${CMAKE_PRIMARY_LANG})
+  execute_process(COMMAND ${CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER} -dumpmachine
+    OUTPUT_VARIABLE __GCC_TARGET_MACHINE
+    OUTPUT_STRIP_TRAILING_WHITESPACE)
+  if(__GCC_TARGET_MACHINE MATCHES "amd64|x86_64|AMD64")
+    set(MINGW64 1)
+  endif()
+  unset(__GCC_TARGET_MACHINE)
+endif()
+
+if(CMAKE_COMPILER_IS_ELBRUSC OR CMAKE_SYSTEM_PROCESSOR MATCHES "e2k.*|E2K.*|elbrus.*|ELBRUS.*")
+  set(E2K TRUE)
+elseif(MSVC64 OR MINGW64)
+  set(X86_64 TRUE)
+elseif(MINGW OR (MSVC AND NOT CMAKE_CROSSCOMPILING))
+  set(X86_32 TRUE)
+elseif(CMAKE_COMPILER_IS_ELBRUSC OR CMAKE_SYSTEM_PROCESSOR MATCHES "e2k.*|E2K.*|elbrus.*|ELBRUS.*")
+  set(E2K TRUE)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*")
+  set(X86_64 TRUE)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "i686.*|i386.*|x86.*")
+  set(X86_32 TRUE)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64.*|AARCH64.*|ARM64.*)")
+  set(AARCH64 TRUE)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(arm.*|ARM.*)")
+  set(ARM32 TRUE)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64le.*")
+  set(PPC64LE TRUE)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc)64.*")
+  set(PPC64 TRUE)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(powerpc|ppc).*")
+  set(PPC32 TRUE)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(mips|MIPS)64.*")
+  set(MIPS64 TRUE)
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(mips|MIPS).*")
+  set(MIPS32 TRUE)
+endif()
+
+# Workaround for 32-bit operating systems on 64-bit x86_64 processor
+if(X86_64 AND CMAKE_SIZEOF_VOID_P EQUAL 4 AND NOT FORCE_X86_64)
+  message(STATUS "sizeof(void) = 4 on x86 / x86_64 processor. Assume 32-bit compilation mode (X86=1)")
+  unset(X86_64)
+  set(X86_32 TRUE)
+endif()
+
+if(MSVC)
+  check_compiler_flag("/WX" CC_HAS_WERROR)
+else()
+  #
+  # GCC started to warn for unused result starting from 4.2, and
+  # this is when it introduced -Wno-unused-result
+  # GCC can also be built on top of llvm runtime (on mac).
+  check_compiler_flag("-Wno-unknown-pragmas" CC_HAS_WNO_UNKNOWN_PRAGMAS)
+  check_compiler_flag("-Wextra" CC_HAS_WEXTRA)
+  check_compiler_flag("-Werror" CC_HAS_WERROR)
+  check_compiler_flag("-fexceptions" CC_HAS_FEXCEPTIONS)
+  check_cxx_compiler_flag("-fcxx-exceptions" CC_HAS_FCXX_EXCEPTIONS)
+  check_compiler_flag("-funwind-tables" CC_HAS_FUNWIND_TABLES)
+  check_compiler_flag("-fno-omit-frame-pointer" CC_HAS_FNO_OMIT_FRAME_POINTER)
+  check_compiler_flag("-fno-common" CC_HAS_FNO_COMMON)
+  check_compiler_flag("-ggdb" CC_HAS_GGDB)
+  check_compiler_flag("-fvisibility=hidden" CC_HAS_VISIBILITY)
+  check_compiler_flag("-march=native" CC_HAS_ARCH_NATIVE)
+  check_compiler_flag("-Og" CC_HAS_DEBUG_FRENDLY_OPTIMIZATION)
+  check_compiler_flag("-Wall" CC_HAS_WALL)
+  check_compiler_flag("-Ominimal" CC_HAS_OMINIMAL)
+  check_compiler_flag("-ffunction-sections -fdata-sections" CC_HAS_SECTIONS)
+  check_compiler_flag("-ffast-math" CC_HAS_FASTMATH)
+
+  # Check for an omp support
+  set(CMAKE_REQUIRED_FLAGS "-fopenmp -Werror")
+  check_cxx_source_compiles("int main(void) {
+    #pragma omp parallel
+    return 0;
+    }" HAVE_OPENMP)
+  set(CMAKE_REQUIRED_FLAGS "")
+endif()
+
+# Check for LTO support by GCC
+if(CMAKE_COMPILER_IS_GNU${CMAKE_PRIMARY_LANG})
+  unset(gcc_collect)
+  unset(gcc_lto_wrapper)
+
+  if(NOT CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER_VERSION VERSION_LESS 4.7)
+    execute_process(COMMAND ${CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER} -v
+      OUTPUT_VARIABLE gcc_info_v ERROR_VARIABLE gcc_info_v)
+
+    string(REGEX MATCH "^(.+\nCOLLECT_GCC=)([^ \n]+)(\n.+)$" gcc_collect_valid ${gcc_info_v})
+    if(gcc_collect_valid)
+      string(REGEX REPLACE "^(.+\nCOLLECT_GCC=)([^ \n]+)(\n.+)$" "\\2" gcc_collect ${gcc_info_v})
+    endif()
+
+    string(REGEX MATCH "^(.+\nCOLLECT_LTO_WRAPPER=)([^ \n]+/lto-wrapper)(\n.+)$" gcc_lto_wrapper_valid ${gcc_info_v})
+    if(gcc_lto_wrapper_valid)
+      string(REGEX REPLACE "^(.+\nCOLLECT_LTO_WRAPPER=)([^ \n]+/lto-wrapper)(\n.+)$" "\\2" gcc_lto_wrapper ${gcc_info_v})
+    endif()
+
+    set(gcc_suffix "")
+    if(gcc_collect_valid AND gcc_collect)
+      string(REGEX MATCH "^(.*cc)(-.+)$" gcc_suffix_valid ${gcc_collect})
+      if(gcc_suffix_valid)
+        string(REGEX MATCH "^(.*cc)(-.+)$" "\\2" gcc_suffix ${gcc_collect})
+      endif()
+    endif()
+
+    get_filename_component(gcc_dir ${CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER} DIRECTORY)
+    if(NOT CMAKE_GCC_AR)
+      find_program(CMAKE_GCC_AR NAMES gcc${gcc_suffix}-ar gcc-ar${gcc_suffix} PATHS ${gcc_dir} NO_DEFAULT_PATH)
+    endif()
+    if(NOT CMAKE_GCC_NM)
+      find_program(CMAKE_GCC_NM NAMES gcc${gcc_suffix}-nm gcc-nm${gcc_suffix} PATHS ${gcc_dir} NO_DEFAULT_PATH)
+    endif()
+    if(NOT CMAKE_GCC_RANLIB)
+      find_program(CMAKE_GCC_RANLIB NAMES gcc${gcc_suffix}-ranlib gcc-ranlib${gcc_suffix} PATHS ${gcc_dir} NO_DEFAULT_PATH)
+    endif()
+
+    unset(gcc_dir)
+    unset(gcc_suffix_valid)
+    unset(gcc_suffix)
+    unset(gcc_lto_wrapper_valid)
+    unset(gcc_collect_valid)
+    unset(gcc_collect)
+    unset(gcc_info_v)
+  endif()
+
+  if(CMAKE_GCC_AR AND CMAKE_GCC_NM AND CMAKE_GCC_RANLIB AND gcc_lto_wrapper)
+    message(STATUS "Found GCC's LTO toolset: ${gcc_lto_wrapper}, ${CMAKE_GCC_AR}, ${CMAKE_GCC_RANLIB}")
+    set(GCC_LTO_CFLAGS "-flto -fno-fat-lto-objects -fuse-linker-plugin")
+    set(GCC_LTO_AVAILABLE TRUE)
+    message(STATUS "Link-Time Optimization by GCC is available")
+  else()
+    set(GCC_LTO_AVAILABLE FALSE)
+    message(STATUS "Link-Time Optimization by GCC is NOT available")
+  endif()
+  unset(gcc_lto_wrapper)
+endif()
+
+# check for LTO by MSVC
+if(MSVC)
+  if(NOT MSVC_VERSION LESS 1600)
+    set(MSVC_LTO_AVAILABLE TRUE)
+    message(STATUS "Link-Time Optimization by MSVC is available")
+  else()
+    set(MSVC_LTO_AVAILABLE FALSE)
+    message(STATUS "Link-Time Optimization by MSVC is NOT available")
+  endif()
+endif()
+
+# Check for LTO support by CLANG
+if(CMAKE_COMPILER_IS_CLANG)
+  if(NOT CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER_VERSION VERSION_LESS 3.5)
+    execute_process(COMMAND ${CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER} -print-search-dirs
+      OUTPUT_VARIABLE clang_search_dirs)
+
+    unset(clang_bindir)
+    unset(clang_libdir)
+    string(REGEX MATCH "^(.*programs: =)([^:]*:)*([^:]+/llvm[-.0-9]+/bin[^:]*)(:[^:]*)*(\n.+)$" clang_bindir_valid ${clang_search_dirs})
+    if(clang_bindir_valid)
+      string(REGEX REPLACE "^(.*programs: =)([^:]*:)*([^:]+/llvm[-.0-9]+/bin[^:]*)(:[^:]*)*(\n.+)$" "\\3" clang_bindir ${clang_search_dirs})
+      get_filename_component(clang_libdir "${clang_bindir}/../lib" REALPATH)
+      if(clang_libdir)
+        message(STATUS "Found CLANG/LLVM directories: ${clang_bindir}, ${clang_libdir}")
+      endif()
+    endif()
+
+    if(NOT (clang_bindir AND clang_libdir))
+      message(STATUS "Could NOT find CLANG/LLVM directories (bin and/or lib).")
+    endif()
+
+    if(NOT CMAKE_CLANG_LD AND clang_bindir)
+      find_program(CMAKE_CLANG_LD NAMES llvm-link link llvm-ld ld PATHS ${clang_bindir} NO_DEFAULT_PATH)
+    endif()
+    if(NOT CMAKE_CLANG_AR AND clang_bindir)
+      find_program(CMAKE_CLANG_AR NAMES llvm-ar ar PATHS ${clang_bindir} NO_DEFAULT_PATH)
+    endif()
+    if(NOT CMAKE_CLANG_NM AND clang_bindir)
+      find_program(CMAKE_CLANG_NM NAMES llvm-nm nm PATHS ${clang_bindir} NO_DEFAULT_PATH)
+    endif()
+    if(NOT CMAKE_CLANG_RANLIB AND clang_bindir)
+      find_program(CMAKE_CLANG_RANLIB NAMES llvm-ranlib ranlib PATHS ${clang_bindir} NO_DEFAULT_PATH)
+    endif()
+
+    set(clang_lto_plugin_name "LLVMgold${CMAKE_SHARED_LIBRARY_SUFFIX}")
+    if(NOT CMAKE_LD_GOLD AND clang_bindir)
+      find_program(CMAKE_LD_GOLD NAMES ld.gold PATHS)
+    endif()
+    if(NOT CLANG_LTO_PLUGIN AND clang_libdir)
+      find_file(CLANG_LTO_PLUGIN ${clang_lto_plugin_name} PATH ${clang_libdir} NO_DEFAULT_PATH)
+    endif()
+    if(CLANG_LTO_PLUGIN)
+      message(STATUS "Found CLANG/LLVM's plugin for LTO: ${CLANG_LTO_PLUGIN}")
+    else()
+      message(STATUS "Could NOT find CLANG/LLVM's plugin (${clang_lto_plugin_name}) for LTO.")
+    endif()
+
+    if(CMAKE_CLANG_LD AND CMAKE_CLANG_AR AND CMAKE_CLANG_NM AND CMAKE_CLANG_RANLIB)
+      message(STATUS "Found CLANG/LLVM's binutils for LTO: ${CMAKE_CLANG_AR}, ${CMAKE_CLANG_RANLIB}")
+    else()
+      message(STATUS "Could NOT find CLANG/LLVM's binutils (ar, ranlib, nm) for LTO.")
+    endif()
+
+    unset(clang_lto_plugin_name)
+    unset(clang_libdir)
+    unset(clang_bindir_valid)
+    unset(clang_bindir)
+    unset(clang_search_dirs)
+  endif()
+
+  if((CLANG_LTO_PLUGIN AND CMAKE_LD_GOLD) AND
+      (CMAKE_CLANG_LD AND CMAKE_CLANG_AR AND CMAKE_CLANG_NM AND CMAKE_CLANG_RANLIB))
+    set(CLANG_LTO_AVAILABLE TRUE)
+    message(STATUS "Link-Time Optimization by CLANG/LLVM is available")
+  elseif(CMAKE_TOOLCHAIN_FILE AND NOT CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER_VERSION VERSION_LESS 7.0)
+    set(CLANG_LTO_AVAILABLE TRUE)
+    if (NOT CMAKE_CLANG_AR)
+      set(CMAKE_CLANG_AR ${CMAKE_AR})
+    endif()
+    if (NOT CMAKE_CLANG_NM)
+      set(CMAKE_CLANG_NM ${CMAKE_NM})
+    endif()
+    if (NOT CMAKE_CLANG_RANLIB)
+      set(CMAKE_CLANG_RANLIB ${CMAKE_RANLIB })
+    endif()
+    message(STATUS "Assume Link-Time Optimization by CLANG/LLVM is available via ${CMAKE_TOOLCHAIN_FILE}")
+  else()
+    set(CLANG_LTO_AVAILABLE FALSE)
+    message(STATUS "Link-Time Optimization by CLANG/LLVM is NOT available")
+  endif()
+endif()
+
+# Perform build type specific configuration.
+option(ENABLE_BACKTRACE "Enable output of fiber backtrace information in 'show
+  fiber' administrative command. Only works on x86 architectures, if compiled
+  with gcc. If GNU binutils and binutils-dev libraries are installed, backtrace
+  is output with resolved function (symbol) names. Otherwise only frame
+  addresses are printed." OFF)
+
+set(HAVE_BFD False)
+if(ENABLE_BACKTRACE)
+  if(NOT (X86_32 OR X86_64) OR NOT CMAKE_COMPILER_IS_GNU${CMAKE_PRIMARY_LANG})
+    # We only know this option to work with gcc
+    message(FATAL_ERROR "ENABLE_BACKTRACE option is set but the system
+      is not x86 based (${CMAKE_SYSTEM_PROCESSOR}) or the compiler
+      is not GNU GCC (${CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER}).")
+  endif()
+  # Use GNU bfd if present.
+  find_library(BFD_LIBRARY NAMES libbfd.a)
+  if(BFD_LIBRARY)
+    check_library_exists(${BFD_LIBRARY} bfd_init "" HAVE_BFD_LIB)
+  endif()
+  find_library(IBERTY_LIBRARY NAMES libiberty.a)
+  if(IBERTY_LIBRARY)
+    check_library_exists(${IBERTY_LIBRARY} cplus_demangle "" HAVE_IBERTY_LIB)
+  endif()
+  set(CMAKE_REQUIRED_DEFINITIONS -DPACKAGE=${PACKAGE} -DPACKAGE_VERSION=${PACKAGE_VERSION})
+  check_include_files(bfd.h HAVE_BFD_H)
+  set(CMAKE_REQUIRED_DEFINITIONS)
+  find_package(ZLIB)
+  if(HAVE_BFD_LIB AND HAVE_BFD_H AND HAVE_IBERTY_LIB AND ZLIB_FOUND)
+    set(HAVE_BFD ON)
+    set(BFD_LIBRARIES ${BFD_LIBRARY} ${IBERTY_LIBRARY} ${ZLIB_LIBRARIES})
+    find_package_message(BFD_LIBRARIES "Found libbfd and dependencies"
+      ${BFD_LIBRARIES})
+    if(TARGET_OS_FREEBSD AND NOT TARGET_OS_DEBIAN_FREEBSD)
+      set(BFD_LIBRARIES ${BFD_LIBRARIES} iconv)
+    endif()
+  endif()
+endif()
+
+macro(setup_compile_flags)
+  # LY: save initial C/CXX flags
+  if(NOT INITIAL_CMAKE_FLAGS_SAVED)
+    if(MSVC)
+      string(REGEX REPLACE "^(.*)(/EHsc)( *)(.*)$" "\\1/EHs\\3\\4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
+    endif()
+    set(INITIAL_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS} CACHE STRING "Initial CMake's flags" FORCE)
+    set(INITIAL_CMAKE_C_FLAGS ${CMAKE_C_FLAGS} CACHE STRING "Initial CMake's flags" FORCE)
+    set(INITIAL_CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS} CACHE STRING "Initial CMake's flags" FORCE)
+    set(INITIAL_CMAKE_SHARED_LINKER_FLAGS ${CMAKE_SHARED_LINKER_FLAGS} CACHE STRING "Initial CMake's flags" FORCE)
+    set(INITIAL_CMAKE_STATIC_LINKER_FLAGS ${CMAKE_STATIC_LINKER_FLAGS} CACHE STRING "Initial CMake's flags" FORCE)
+    set(INITIAL_CMAKE_MODULE_LINKER_FLAGS ${CMAKE_MODULE_LINKER_FLAGS} CACHE STRING "Initial CMake's flags" FORCE)
+    set(INITIAL_CMAKE_FLAGS_SAVED TRUE CACHE INTERNAL "State of initial CMake's flags" FORCE)
+  endif()
+
+  # LY: reset C/CXX flags
+  set(CXX_FLAGS ${INITIAL_CMAKE_CXX_FLAGS})
+  set(C_FLAGS ${INITIAL_CMAKE_C_FLAGS})
+  set(EXE_LINKER_FLAGS ${INITIAL_CMAKE_EXE_LINKER_FLAGS})
+  set(SHARED_LINKER_FLAGS ${INITIAL_CMAKE_SHARED_LINKER_FLAGS})
+  set(STATIC_LINKER_FLAGS ${INITIAL_CMAKE_STATIC_LINKER_FLAGS})
+  set(MODULE_LINKER_FLAGS ${INITIAL_CMAKE_MODULE_LINKER_FLAGS})
+
+  if(CC_HAS_FEXCEPTIONS)
+    add_compile_flags("C;CXX" "-fexceptions")
+  endif()
+  if(CC_HAS_FCXX_EXCEPTIONS)
+    add_compile_flags("CXX" "-fcxx-exceptions -frtti")
+  endif()
+
+  # In C a global variable without a storage specifier (static/extern) and
+  # without an initialiser is called a ’tentative definition’. The
+  # language permits multiple tentative definitions in the single
+  # translation unit; i.e. int foo; int foo; is perfectly ok. GNU
+  # toolchain goes even further, allowing multiple tentative definitions
+  # in *different* translation units. Internally, variables introduced via
+  # tentative definitions are implemented as ‘common’ symbols. Linker
+  # permits multiple definitions if they are common symbols, and it picks
+  # one arbitrarily for inclusion in the binary being linked.
+  #
+  # -fno-common forces GNU toolchain to behave in a more
+  # standard-conformant way in respect to tentative definitions and it
+  # prevents common symbols generation. Since we are a cross-platform
+  # project it really makes sense. There are toolchains that don’t
+  # implement GNU style handling of the tentative definitions and there
+  # are platforms lacking proper support for common symbols (osx).
+  if(CC_HAS_FNO_COMMON)
+    add_compile_flags("C;CXX" "-fno-common")
+  endif()
+
+  if(CC_HAS_GGDB)
+    add_compile_flags("C;CXX" "-ggdb")
+  endif()
+
+  if(CC_HAS_WNO_UNKNOWN_PRAGMAS AND NOT HAVE_OPENMP)
+    add_compile_flags("C;CXX" -Wno-unknown-pragmas)
+  endif()
+
+  if(CC_HAS_SECTIONS)
+    add_compile_flags("C;CXX" -ffunction-sections -fdata-sections)
+  elseif(MSVC)
+    add_compile_flags("C;CXX" /Gy)
+  endif()
+
+  # We must set -fno-omit-frame-pointer here, since we rely
+  # on frame pointer when getting a backtrace, and it must
+  # be used consistently across all object files.
+  # The same reasoning applies to -fno-stack-protector switch.
+  if(ENABLE_BACKTRACE)
+    if(CC_HAS_FNO_OMIT_FRAME_POINTER)
+      add_compile_flags("C;CXX" "-fno-omit-frame-pointer")
+    endif()
+  endif()
+
+  if(MSVC)
+    if (MSVC_VERSION LESS 1915)
+      message(FATAL_ERROR At least \"Microsoft C/C++ Compiler\" version 19.15.26730 (Visual Studio 2017 15.8) is required.)
+    endif()
+    add_compile_flags("CXX" "/Zc:__cplusplus")
+    add_compile_flags("C;CXX" "/W4")
+    add_compile_flags("C;CXX" "/utf-8")
+  else()
+    if(CC_HAS_WALL)
+      add_compile_flags("C;CXX" "-Wall")
+    endif()
+    if(CC_HAS_WEXTRA)
+      add_compile_flags("C;CXX" "-Wextra")
+    endif()
+  endif()
+
+  if(CMAKE_COMPILER_IS_GNU${CMAKE_PRIMARY_LANG}
+      AND CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER_VERSION VERSION_LESS 5)
+    # G++ bug. http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31488
+    add_compile_flags("CXX" "-Wno-invalid-offsetof")
+  endif()
+
+  add_definitions("-D__STDC_FORMAT_MACROS=1")
+  add_definitions("-D__STDC_LIMIT_MACROS=1")
+  add_definitions("-D__STDC_CONSTANT_MACROS=1")
+  add_definitions("-D_HAS_EXCEPTIONS=1")
+
+  # Only add -Werror if it's a debug build, done by developers.
+  # Release builds should not cause extra trouble.
+  if(CC_HAS_WERROR AND (CI OR CMAKE_CONFIGURATION_TYPES OR CMAKE_BUILD_TYPE STREQUAL "Debug"))
+    if(MSVC)
+      add_compile_flags("C;CXX" "/WX")
+    elseif(CMAKE_COMPILER_IS_CLANG)
+      if (NOT CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER_VERSION VERSION_LESS 6)
+        add_compile_flags("C;CXX" "-Werror")
+      endif()
+    elseif(CMAKE_COMPILER_IS_GNUCC)
+      if (NOT CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER_VERSION VERSION_LESS 6)
+        add_compile_flags("C;CXX" "-Werror")
+      endif()
+    else()
+      add_compile_flags("C;CXX" "-Werror")
+    endif()
+  endif()
+
+  if(HAVE_OPENMP)
+    add_compile_flags("C;CXX" "-fopenmp")
+  endif()
+
+  if (ENABLE_ASAN)
+    add_compile_flags("C;CXX" -fsanitize=address)
+  endif()
+
+  if(ENABLE_GCOV)
+    if(NOT HAVE_GCOV)
+      message(FATAL_ERROR
+        "ENABLE_GCOV option requested but gcov library is not found")
+    endif()
+
+    add_compile_flags("C;CXX" "-fprofile-arcs" "-ftest-coverage")
+    set(EXE_LINKER_FLAGS "${EXE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
+    set(SHARED_LINKER_FLAGS "${SHARED_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
+    set(MODULE_LINKER_FLAGS "${MODULE_LINKER_FLAGS} -fprofile-arcs -ftest-coverage")
+    # add_library(gcov SHARED IMPORTED)
+  endif()
+
+  if(ENABLE_GPROF)
+    add_compile_flags("C;CXX" "-pg")
+  endif()
+
+  if(CMAKE_COMPILER_IS_GNUCC AND LTO_ENABLED)
+    add_compile_flags("C;CXX" ${GCC_LTO_CFLAGS})
+    set(EXE_LINKER_FLAGS "${EXE_LINKER_FLAGS} ${GCC_LTO_CFLAGS} -fverbose-asm -fwhole-program")
+    set(SHARED_LINKER_FLAGS "${SHARED_LINKER_FLAGS} ${GCC_LTO_CFLAGS} -fverbose-asm")
+    set(MODULE_LINKER_FLAGS "${MODULE_LINKER_FLAGS} ${GCC_LTO_CFLAGS} -fverbose-asm")
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5)
+      # Pass the same optimization flags to the linker
+      set(compile_flags "${CMAKE_C_FLAGS} ${CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UPPERCASE}}")
+      set(EXE_LINKER_FLAGS "${EXE_LINKER_FLAGS} ${compile_flags}")
+      set(SHARED_LINKER_FLAGS "${SHARED_LINKER_FLAGS} ${compile_flags}")
+      set(MODULE_LINKER_FLAGS "${MODULE_LINKER_FLAGS} ${compile_flags}")
+      unset(compile_flags)
+    else()
+      add_compile_flags("CXX" "-flto-odr-type-merging")
+    endif()
+  endif()
+
+  if(MSVC AND LTO_ENABLED)
+    add_compile_flags("C;CXX" "/GL")
+    foreach(linkmode IN ITEMS EXE SHARED STATIC MODULE)
+      set(${linkmode}_LINKER_FLAGS "${${linkmode}_LINKER_FLAGS} /LTCG")
+      string(REGEX REPLACE "^(.*)(/INCREMENTAL:NO *)(.*)$" "\\1\\3" ${linkmode}_LINKER_FLAGS "${${linkmode}_LINKER_FLAGS}")
+      string(REGEX REPLACE "^(.*)(/INCREMENTAL:YES *)(.*)$" "\\1\\3" ${linkmode}_LINKER_FLAGS "${${linkmode}_LINKER_FLAGS}")
+      string(REGEX REPLACE "^(.*)(/INCREMENTAL *)(.*)$" "\\1\\3" ${linkmode}_LINKER_FLAGS "${${linkmode}_LINKER_FLAGS}")
+      string(STRIP "${${linkmode}_LINKER_FLAGS}" ${linkmode}_LINKER_FLAGS)
+      foreach(config IN LISTS CMAKE_CONFIGURATION_TYPES ITEMS Release MinSizeRel RelWithDebInfo Debug)
+        string(TOUPPER "${config}" config_uppercase)
+        if(DEFINED "CMAKE_${linkmode}_LINKER_FLAGS_${config_uppercase}")
+          string(REGEX REPLACE "^(.*)(/INCREMENTAL:NO *)(.*)$" "\\1\\3" altered_flags "${CMAKE_${linkmode}_LINKER_FLAGS_${config_uppercase}}")
+          string(REGEX REPLACE "^(.*)(/INCREMENTAL:YES *)(.*)$" "\\1\\3" altered_flags "${altered_flags}")
+          string(REGEX REPLACE "^(.*)(/INCREMENTAL *)(.*)$" "\\1\\3" altered_flags "${altered_flags}")
+          string(STRIP "${altered_flags}" altered_flags)
+          if(NOT "${altered_flags}" STREQUAL "${CMAKE_${linkmode}_LINKER_FLAGS_${config_uppercase}}")
+            set(CMAKE_${linkmode}_LINKER_FLAGS_${config_uppercase} "${altered_flags}" CACHE STRING "Altered: '/INCREMENTAL' removed for LTO" FORCE)
+          endif()
+        endif()
+      endforeach(config)
+    endforeach(linkmode)
+    unset(linkmode)
+
+    foreach(config IN LISTS CMAKE_CONFIGURATION_TYPES ITEMS Release MinSizeRel RelWithDebInfo)
+      foreach(lang IN ITEMS C CXX)
+        string(TOUPPER "${config}" config_uppercase)
+        if(DEFINED "CMAKE_${lang}_FLAGS_${config_uppercase}")
+          string(REPLACE "/O2" "/Ox" altered_flags "${CMAKE_${lang}_FLAGS_${config_uppercase}}")
+          if(NOT "${altered_flags}" STREQUAL "${CMAKE_${lang}_FLAGS_${config_uppercase}}")
+            set(CMAKE_${lang}_FLAGS_${config_uppercase} "${altered_flags}" CACHE STRING "Altered: '/O2' replaced by '/Ox' for LTO" FORCE)
+          endif()
+        endif()
+        unset(config_uppercase)
+      endforeach(lang)
+    endforeach(config)
+    unset(altered_flags)
+    unset(lang)
+    unset(config)
+  endif()
+
+  if(CMAKE_COMPILER_IS_CLANG AND OSX_ARCHITECTURES)
+    set(EXE_LINKER_FLAGS "${EXE_LINKER_FLAGS} -Wl,-keep_dwarf_unwind")
+    set(SHARED_LINKER_FLAGS "${SHARED_LINKER_FLAGS} -Wl,-keep_dwarf_unwind")
+    set(MODULE_LINKER_FLAGS "${MODULE_LINKER_FLAGS} -Wl,-keep_dwarf_unwind")
+  endif()
+
+  if(CMAKE_COMPILER_IS_CLANG AND LTO_ENABLED)
+    if(CMAKE_${CMAKE_PRIMARY_LANG}_COMPILER_VERSION VERSION_LESS 3.9)
+      set(CLANG_LTO_FLAG "-flto")
+    else()
+      set(CLANG_LTO_FLAG "-flto=thin")
+    endif()
+    add_compile_flags("C;CXX" ${CLANG_LTO_FLAG})
+    set(EXE_LINKER_FLAGS "${EXE_LINKER_FLAGS} ${CLANG_LTO_FLAG} -fverbose-asm -fwhole-program")
+    set(SHARED_LINKER_FLAGS "${SHARED_LINKER_FLAGS} ${CLANG_LTO_FLAG} -fverbose-asm")
+    set(MODULE_LINKER_FLAGS "${MODULE_LINKER_FLAGS} ${CLANG_LTO_FLAG} -fverbose-asm")
+  endif()
+
+  # LY: push C/CXX flags into the cache
+  set(CMAKE_CXX_FLAGS ${CXX_FLAGS} CACHE STRING "Flags used by the C++ compiler during all build types" FORCE)
+  set(CMAKE_C_FLAGS ${C_FLAGS} CACHE STRING "Flags used by the C compiler during all build types" FORCE)
+  set(CMAKE_EXE_LINKER_FLAGS ${EXE_LINKER_FLAGS} CACHE STRING "Flags used by the linker" FORCE)
+  set(CMAKE_SHARED_LINKER_FLAGS ${SHARED_LINKER_FLAGS} CACHE STRING "Flags used by the linker during the creation of dll's" FORCE)
+  set(CMAKE_STATIC_LINKER_FLAGS ${STATIC_LINKER_FLAGS} CACHE STRING "Flags used by the linker during the creation of static libraries" FORCE)
+  set(CMAKE_MODULE_LINKER_FLAGS ${MODULE_LINKER_FLAGS} CACHE STRING "Flags used by the linker during the creation of modules" FORCE)
+  unset(CXX_FLAGS)
+  unset(C_FLAGS)
+  unset(EXE_LINKER_FLAGS)
+  unset(SHARED_LINKER_FLAGS)
+  unset(STATIC_LINKER_FLAGS)
+  unset(MODULE_LINKER_FLAGS)
+endmacro(setup_compile_flags)
+
+# determine library for for std::filesystem
+set(LIBCXX_FILESYSTEM "")
+if(CMAKE_COMPILER_IS_GNUCXX)
+  if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 9.0)
+    set(LIBCXX_FILESYSTEM "stdc++fs")
+  endif()
+elseif (CMAKE_COMPILER_IS_CLANG)
+  if (CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.0)
+    set(LIBCXX_FILESYSTEM "c++experimental")
+  else()
+    set(LIBCXX_FILESYSTEM "stdc++fs")
+  endif()
+endif()
+
+cmake_policy(POP)

cmake/profile.cmake

@@ -0,0 +1,45 @@
+##  Copyright (c) 2012-2019 Leonid Yuriev <leo@yuriev.ru>.
+##
+##  Licensed under the Apache License, Version 2.0 (the "License");
+##  you may not use this file except in compliance with the License.
+##  You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+##  Unless required by applicable law or agreed to in writing, software
+##  distributed under the License is distributed on an "AS IS" BASIS,
+##  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+##  See the License for the specific language governing permissions and
+##  limitations under the License.
+##
+
+cmake_minimum_required(VERSION 3.8.2)
+cmake_policy(PUSH)
+cmake_policy(VERSION 3.8.2)
+
+include(CheckLibraryExists)
+check_library_exists(gcov __gcov_flush "" HAVE_GCOV)
+
+option(ENABLE_GCOV
+  "Enable integration with gcov, a code coverage program" OFF)
+
+option(ENABLE_GPROF
+  "Enable integration with gprof, a performance analyzing tool" OFF)
+
+if(CMAKE_CXX_COMPILER_LOADED)
+  include(CheckIncludeFileCXX)
+  check_include_file_cxx(valgrind/memcheck.h HAVE_VALGRIND_MEMCHECK_H)
+else()
+  include(CheckIncludeFile)
+  check_include_file(valgrind/memcheck.h HAVE_VALGRIND_MEMCHECK_H)
+endif()
+
+option(ENABLE_VALGRIND "Enable integration with valgrind, a memory analyzing tool" OFF)
+if(ENABLE_VALGRIND AND NOT HAVE_VALGRIND_MEMCHECK_H)
+  message(FATAL_ERROR "ENABLE_VALGRIND option is set but valgrind/memcheck.h is not found")
+endif()
+
+option(ENABLE_ASAN
+  "Enable AddressSanitizer, a fast memory error detector based on compiler instrumentation" OFF)
+
+cmake_policy(POP)

cmake/utils.cmake

@@ -0,0 +1,183 @@
+##  Copyright (c) 2012-2019 Leonid Yuriev <leo@yuriev.ru>.
+##
+##  Licensed under the Apache License, Version 2.0 (the "License");
+##  you may not use this file except in compliance with the License.
+##  You may obtain a copy of the License at
+##
+##      http://www.apache.org/licenses/LICENSE-2.0
+##
+##  Unless required by applicable law or agreed to in writing, software
+##  distributed under the License is distributed on an "AS IS" BASIS,
+##  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+##  See the License for the specific language governing permissions and
+##  limitations under the License.
+##
+
+cmake_minimum_required(VERSION 3.8.2)
+cmake_policy(PUSH)
+cmake_policy(VERSION 3.8.2)
+
+macro(add_compile_flags langs)
+  foreach(_lang ${langs})
+    string(REPLACE ";" " " _flags "${ARGN}")
+    if(CMAKE_CXX_COMPILER_LOADED AND _lang STREQUAL "CXX")
+      set("${_lang}_FLAGS" "${${_lang}_FLAGS} ${_flags}")
+    endif()
+    if(CMAKE_C_COMPILER_LOADED AND _lang STREQUAL "C")
+      set("${_lang}_FLAGS" "${${_lang}_FLAGS} ${_flags}")
+    endif()
+  endforeach()
+  unset(_lang)
+  unset(_flags)
+endmacro(add_compile_flags)
+
+macro(set_source_files_compile_flags)
+  foreach(file ${ARGN})
+    get_filename_component(_file_ext ${file} EXT)
+    set(_lang "")
+    if("${_file_ext}" STREQUAL ".m")
+      set(_lang OBJC)
+      # CMake believes that Objective C is a flavor of C++, not C,
+      # and uses g++ compiler for .m files.
+      # LANGUAGE property forces CMake to use CC for ${file}
+      set_source_files_properties(${file} PROPERTIES LANGUAGE C)
+    elseif("${_file_ext}" STREQUAL ".mm")
+      set(_lang OBJCXX)
+    endif()
+
+    if(_lang)
+      get_source_file_property(_flags ${file} COMPILE_FLAGS)
+      if("${_flags}" STREQUAL "NOTFOUND")
+        set(_flags "${CMAKE_${_lang}_FLAGS}")
+      else()
+        set(_flags "${_flags} ${CMAKE_${_lang}_FLAGS}")
+      endif()
+      # message(STATUS "Set (${file} ${_flags}")
+      set_source_files_properties(${file} PROPERTIES COMPILE_FLAGS
+        "${_flags}")
+    endif()
+  endforeach()
+  unset(_file_ext)
+  unset(_lang)
+endmacro(set_source_files_compile_flags)
+
+macro(fetch_version name version_file)
+  set(${name}_VERSION "")
+  set(${name}_GIT_DESCRIBE "")
+  set(${name}_GIT_TIMESTAMP "")
+  set(${name}_GIT_TREE "")
+  set(${name}_GIT_COMMIT "")
+  set(${name}_GIT_REVISION 0)
+  set(${name}_GIT_VERSION "")
+  if(GIT)
+    execute_process(COMMAND ${GIT} describe --tags --long --dirty=-dirty
+      OUTPUT_VARIABLE ${name}_GIT_DESCRIBE
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      RESULT_VARIABLE rc)
+    if(rc OR "${name}_GIT_DESCRIBE" STREQUAL "")
+      message(FATAL_ERROR "Please fetch tags and/or install latest version of git ('describe --tags --long --dirty' failed)")
+    endif()
+
+    execute_process(COMMAND ${GIT} show --no-patch --format=%cI HEAD
+      OUTPUT_VARIABLE ${name}_GIT_TIMESTAMP
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      RESULT_VARIABLE rc)
+    if(rc OR "${name}_GIT_TIMESTAMP" STREQUAL "%cI")
+      execute_process(COMMAND ${GIT} show --no-patch --format=%ci HEAD
+        OUTPUT_VARIABLE ${name}_GIT_TIMESTAMP
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+        RESULT_VARIABLE rc)
+      if(rc OR "${name}_GIT_TIMESTAMP" STREQUAL "%ci")
+        message(FATAL_ERROR "Please install latest version of git ('show --no-patch --format=%cI HEAD' failed)")
+      endif()
+    endif()
+
+    execute_process(COMMAND ${GIT} show --no-patch --format=%T HEAD
+      OUTPUT_VARIABLE ${name}_GIT_TREE
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      RESULT_VARIABLE rc)
+    if(rc OR "${name}_GIT_TREE" STREQUAL "")
+      message(FATAL_ERROR "Please install latest version of git ('show --no-patch --format=%T HEAD' failed)")
+    endif()
+
+    execute_process(COMMAND ${GIT} show --no-patch --format=%H HEAD
+      OUTPUT_VARIABLE ${name}_GIT_COMMIT
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      RESULT_VARIABLE rc)
+    if(rc OR "${name}_GIT_COMMIT" STREQUAL "")
+      message(FATAL_ERROR "Please install latest version of git ('show --no-patch --format=%H HEAD' failed)")
+    endif()
+
+    execute_process(COMMAND ${GIT} rev-list --count --no-merges HEAD
+      OUTPUT_VARIABLE ${name}_GIT_REVISION
+      OUTPUT_STRIP_TRAILING_WHITESPACE
+      WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
+      RESULT_VARIABLE rc)
+    if(rc OR "${name}_GIT_REVISION" STREQUAL "")
+      message(FATAL_ERROR "Please install latest version of git ('rev-list --count --no-merges HEAD' failed)")
+    endif()
+
+    string(REGEX MATCH "^(v)?([0-9]+)\\.([0-9]+)\\.([0-9]+)(.*)?" git_version_valid "${${name}_GIT_DESCRIBE}")
+    if(git_version_valid)
+      string(REGEX REPLACE "^(v)?([0-9]+)\\.([0-9]+)\\.([0-9]+)(.*)?" "\\2;\\3;\\4" ${name}_GIT_VERSION ${${name}_GIT_DESCRIBE})
+    else()
+      string(REGEX MATCH "^(v)?([0-9]+)\\.([0-9]+)(.*)?" git_version_valid "${${name}_GIT_DESCRIBE}")
+      if(git_version_valid)
+        string(REGEX REPLACE "^(v)?([0-9]+)\\.([0-9]+)(.*)?" "\\2;\\3;0" ${name}_GIT_VERSION ${${name}_GIT_DESCRIBE})
+      else()
+        message(AUTHOR_WARNING "Bad ${name} version \"${${name}_GIT_DESCRIBE}\"; falling back to 0.0.0 (have you made an initial release?)")
+        set(${name}_GIT_VERSION "0;0;0")
+      endif()
+    endif()
+  endif()
+
+  if(NOT ${name}_GIT_VERSION OR NOT ${name}_GIT_TIMESTAMP OR NOT ${name}_GIT_REVISION)
+    message(WARNING "Unable to retrive ${name} version from git.")
+    set(${name}_GIT_VERSION "0;0;0;0")
+    set(${name}_GIT_TIMESTAMP "")
+    set(${name}_GIT_REVISION 0)
+
+    # Try to get version from VERSION file
+    if(EXISTS "${version_file}")
+      file(STRINGS "${version_file}" ${name}_VERSION)
+    endif()
+
+    if(NOT ${name}_VERSION)
+      message(WARNING "Unable to retrive ${name} version from \"${version_file}\" file.")
+      set(${name}_VERSION_LIST ${${name}_GIT_VERSION})
+      string(REPLACE ";" "." ${name}_VERSION "${${name}_GIT_VERSION}")
+    else()
+      string(REPLACE "." ";" ${name}_VERSION_LIST ${${name}_VERSION})
+    endif()
+
+  else()
+    list(APPEND ${name}_GIT_VERSION ${${name}_GIT_REVISION})
+    set(${name}_VERSION_LIST ${${name}_GIT_VERSION})
+    string(REPLACE ";" "." ${name}_VERSION "${${name}_GIT_VERSION}")
+  endif()
+
+  list(GET ${name}_VERSION_LIST 0 "${name}_VERSION_MAJOR")
+  list(GET ${name}_VERSION_LIST 1 "${name}_VERSION_MINOR")
+  list(GET ${name}_VERSION_LIST 2 "${name}_VERSION_RELEASE")
+  list(GET ${name}_VERSION_LIST 3 "${name}_VERSION_REVISION")
+
+  set(${name}_VERSION_MAJOR ${${name}_VERSION_MAJOR} PARENT_SCOPE)
+  set(${name}_VERSION_MINOR ${${name}_VERSION_MINOR} PARENT_SCOPE)
+  set(${name}_VERSION_RELEASE ${${name}_VERSION_RELEASE} PARENT_SCOPE)
+  set(${name}_VERSION_REVISION ${${name}_VERSION_REVISION} PARENT_SCOPE)
+  set(${name}_VERSION ${${name}_VERSION} PARENT_SCOPE)
+
+  set(${name}_GIT_DESCRIBE ${${name}_GIT_DESCRIBE} PARENT_SCOPE)
+  set(${name}_GIT_TIMESTAMP ${${name}_GIT_TIMESTAMP} PARENT_SCOPE)
+  set(${name}_GIT_TREE ${${name}_GIT_TREE} PARENT_SCOPE)
+  set(${name}_GIT_COMMIT ${${name}_GIT_COMMIT} PARENT_SCOPE)
+  set(${name}_GIT_REVISION ${${name}_GIT_REVISION} PARENT_SCOPE)
+  set(${name}_GIT_VERSION ${${name}_GIT_VERSION} PARENT_SCOPE)
+endmacro(fetch_version)
+
+cmake_policy(POP)

libmdbx.files

@@ -1,11 +1,13 @@
 AUTHORS
 CMakeLists.txt
+CMakeLists.txt
 LICENSE
 GNUmakefile
 README-RU.md
 README.md
 TODO.md
 mdbx.h
+src/CMakeLists.txt
 src/alloy.c
 src/elements/data.c
 src/elements/internals.h

libmdbx.includes

@@ -2,3 +2,4 @@
 src/elements
 src/tools
 test
+src

src/CMakeLists.txt

@@ -0,0 +1,165 @@
+##
+##  Copyright 2019 Leonid Yuriev <leo@yuriev.ru>
+##  and other libmdbx authors: please see AUTHORS file.
+##  All rights reserved.
+##
+##  Redistribution and use in source and binary forms, with or without
+##  modification, are permitted only as authorized by the OpenLDAP
+##  Public License.
+##
+##  A copy of this license is available in the file LICENSE in the
+##  top-level directory of the distribution or, alternatively, at
+##  <http://www.OpenLDAP.org/license.html>.
+##
+
+#
+# Get version
+if(HAVE_MDBX_VERSIONINFO)
+  fetch_version(MDBX "${CMAKE_CURRENT_SOURCE_DIR}/../VERSION")
+  message(STATUS "libmdbx version is ${MDBX_VERSION}")
+else()
+  set(MDBX_VERSION "unversioned")
+endif()
+
+add_library(mdbx_objects OBJECT ${CMAKE_CURRENT_BINARY_DIR}/version.c alloy.c)
+set_target_properties(mdbx_objects PROPERTIES
+  INTERPROCEDURAL_OPTIMIZATION $<BOOL:${INTERPROCEDURAL_OPTIMIZATION}>
+  POSITION_INDEPENDENT_CODE ON
+  C_STANDARD 11
+  C_STANDARD_REQUIRED OFF
+  PUBLIC_HEADER "../mdbx.h"
+  )
+target_compile_definitions(mdbx_objects PRIVATE "LIBMDBX_EXPORTS")
+target_include_directories(mdbx_objects PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}" "${CMAKE_CURRENT_BINARY_DIR}")
+
+if(CC_HAS_FASTMATH)
+  target_compile_options(mdbx_objects PRIVATE "-ffast-math")
+endif()
+if(BUILD_FOR_NATIVE_CPU AND CC_HAS_ARCH_NATIVE)
+  target_compile_options(mdbx_objects PUBLIC "-march=native")
+endif()
+if(CC_HAS_VISIBILITY)
+  target_compile_options(mdbx_objects PRIVATE "-fvisibility=hidden")
+endif()
+
+if(BUILD_SHARED_LIBS)
+  set(LIBMDBX_TYPE SHARED)
+else()
+  set(LIBMDBX_TYPE STATIC)
+endif()
+
+add_library(mdbx ${LIBMDBX_TYPE} $<TARGET_OBJECTS:mdbx_objects>)
+target_link_libraries(mdbx INTERFACE ${CMAKE_THREAD_LIBS_INIT})
+if(LIBFPTU_TYPE STREQUAL "SHARED")
+  target_compile_definitions(mdbx INTERFACE "LIBMDBX_IMPORTS")
+  if(CC_HAS_VISIBILITY AND (LTO_ENABLED OR INTERPROCEDURAL_OPTIMIZATION))
+    set_target_properties(mdbx PROPERTIES LINK_FLAGS "-fvisibility=hidden")
+  endif()
+endif()
+
+install(TARGETS mdbx
+  LIBRARY DESTINATION lib COMPONENT runtime
+  RUNTIME DESTINATION bin COMPONENT runtime
+  ARCHIVE DESTINATION lib/static COMPONENT devel
+  PUBLIC_HEADER DESTINATION include/libmdbx INCLUDES DESTINATION include COMPONENT devel
+  )
+
+foreach(file mdbx.h LICENSE README.md AUTHORS)
+  install(FILES "../${file}" DESTINATION "include/libmdbx")
+endforeach()
+
+################################################################################
+#
+# library build info (used in library version output)
+#
+
+# get definitions as a string of "-Dxyz=124 ..."
+get_target_property(MDBX_DEFINITIONS mdbx_objects COMPILE_DEFINITIONS)
+if(NOT MDBX_DEFINITIONS)
+  set(MDBX_DEFINITIONS "")
+endif()
+list(REMOVE_DUPLICATES MDBX_DEFINITIONS)
+string(REGEX REPLACE "([^;]+)" " -D\\1" MDBX_DEFINITIONS "${MDBX_DEFINITIONS}")
+string(STRIP MDBX_DEFINITIONS "${MDBX_DEFINITIONS}")
+
+# get target compile options as a list
+get_target_property(mdbx_compile_options mdbx_objects COMPILE_OPTIONS)
+if(NOT mdbx_compile_options)
+  set(mdbx_compile_options "")
+endif()
+
+# append cmake's common cxx flags and defines
+string(REPLACE " " ";" cmake_cxx_options "${CMAKE_C_FLAGS}" "${CMAKE_C_DEFINES}")
+list(INSERT mdbx_compile_options 0 "${cmake_c_options}")
+unset(cmake_c_options)
+
+# append cmake's build-type flags and defines
+if(NOT CMAKE_CONFIGURATION_TYPES)
+  string(REPLACE " " ";" cmake_cxx_options "${CMAKE_C_FLAGS_${CMAKE_BUILD_TYPE_UPPERCASE}}" "${CMAKE_C_DEFINES_${CMAKE_BUILD_TYPE_UPPERCASE}}")
+  list(APPEND mdbx_compile_options "${cmake_c_options}")
+  unset(cmake_c_options)
+endif()
+
+# append linker dll's options
+if(LIBMDBX_TYPE STREQUAL "SHARED")
+  string(REPLACE " " ";" cmake_shared_linker_options "${CMAKE_SHARED_LINKER_FLAGS}")
+  list(APPEND mdbx_compile_options ${cmake_shared_linker_options})
+  unset(cmake_shared_linker_options)
+endif()
+
+# drop duplicates in the option list
+list(REMOVE_DUPLICATES mdbx_compile_options)
+
+# make string of space separated flags
+string(REPLACE ";" " " MDBX_COMPILE_FLAGS "${mdbx_compile_options}")
+unset(mdbx_compile_options)
+string(STRIP "${MDBX_COMPILE_FLAGS}${MDBX_DEFINITIONS}" MDBX_COMPILE_FLAGS)
+if(CMAKE_CONFIGURATION_TYPES)
+  # add dynamic part via per-configuration define
+  message(STATUS "MDBX Compile Flags: ${MDBX_COMPILE_FLAGS} <AND CONFIGURATION DEPENDENT>")
+  set(MDBX_COMPILE_FLAGS "MDBX_COMPILE_FLAGS \"${MDBX_COMPILE_FLAGS}\"")
+  add_definitions(
+    -DMDBX_COMPILE_FLAGS="$<$<CONFIG:Debug>:${CMAKE_C_FLAGS_DEBUG} ${CMAKE_C_DEFINES_DEBUG}>$<$<CONFIG:Release>:${CMAKE_C_FLAGS_RELEASE} ${CMAKE_C_DEFINES_RELEASE}>$<$<CONFIG:RelWithDebInfo>:${CMAKE_C_FLAGS_RELWITHDEBINFO} ${CMAKE_C_DEFINES_RELWITHDEBINFO}>$<$<CONFIG:MinSizeRel>:${CMAKE_C_FLAGS_MINSIZEREL} ${CMAKE_C_DEFINES_MINSIZEREL}>"
+    )
+else()
+  message(STATUS "MDBX Compile Flags: ${MDBX_COMPILE_FLAGS}")
+  set(MDBX_COMPILE_FLAGS "\"${MDBX_COMPILE_FLAGS}\"")
+endif()
+
+# make a build-target triplet
+if(CMAKE_CONFIGURATION_TYPES)
+  # via per-configuration define
+  add_definitions(-DMDBX_BUILD_TARGET="${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}-$<CONFIG>")
+  set(MDBX_BUILD_TARGET "MDBX_BUILD_TARGET")
+else()
+  string(STRIP "\"${CMAKE_SYSTEM_NAME}-${CMAKE_SYSTEM_PROCESSOR}-${CMAKE_BUILD_TYPE}\"" MDBX_BUILD_TARGET)
+endif()
+
+# generate version file
+string(TIMESTAMP MDBX_BUILD_TIMESTAMP UTC)
+string(REPLACE "  " " " MDBX_OPTIONS "-DCMAKE_INSTALL_PREFIX=${CMAKE_INSTALL_PREFIX}"
+  " -DENABLE_ASAN=${ENABLE_ASAN}"
+  " -DENABLE_VALGRIND=${ENABLE_VALGRIND}"
+  " -DENABLE_GPROF=${ENABLE_GPROF}"
+  " -DENABLE_GCOV=${ENABLE_GCOV}"
+  " -DENABLE_BACKTRACE=${ENABLE_BACKTRACE}"
+  )
+
+string(STRIP "${CMAKE_C_COMPILER_ID}-${CMAKE_C_COMPILER_VERSION}" MDBX_BUILD_COMPILER)
+configure_file(${CMAKE_CURRENT_SOURCE_DIR}/elements/version.c.in ${CMAKE_CURRENT_BINARY_DIR}/version.c)
+
+set(options VERSION C_COMPILER C_COMPILER DEFINITIONS
+  ENABLE_GCOV ENABLE_GPROF ENABLE_VALGRIND ENABLE_BACKTRACE BUILD_TARGET
+  HAVE_BFD ENABLE_ASAN)
+foreach(option IN LISTS options)
+  if(DEFINED MDBX_${option})
+    set(value ${MDBX_${option}})
+  elseif(DEFINED ${option})
+    set(value "${${option}}")
+  else()
+    set(value "${CMAKE_${option}}")
+  endif()
+  message(STATUS "MDBX_${option}: ${value}")
+endforeach(option)
+
+add_subdirectory(tools)

src/alloy.c

@@ -11,17 +11,17 @@
  * top-level directory of the distribution or, alternatively, at
  * <http://www.OpenLDAP.org/license.html>. */
 
-#define MDBX_ALLOY 1 /* Amalgamated build */
+/* Amalgamated build */
-
+#define MDBX_ALLOY 1
-/* Turn off formatters to avoid reordering the #includes */
-/* *INDENT-OFF* */
-/* clang-format off */
-
 #include "elements/internals.h" /* must be included fisrt */
+
 #include "../mdbx.h"
 #include "elements/defs.h"
 #include "elements/osal.h"
 
+#include "elements/core.c"
+#include "elements/osal.c"
+
 #if defined(__linux__) || defined(__gnu_linux__)
 #include "elements/lck-linux.c"
 #elif defined(_WIN32) || defined(_WIN64)
@@ -29,10 +29,3 @@
 #else
 #include "elements/lck-posix.c"
 #endif
-
-#include "elements/osal.c"
-#include "elements/core.c"
-#include "elements/version.c.in"
-
-/* *INDENT-ON* */
-/* clang-format on */

src/elements/config.h.in

@@ -0,0 +1,16 @@
+#cmakedefine HAVE_UNISTD_H
+#cmakedefine HAVE_SYS_UIO_H
+#cmakedefine HAVE_SYS_STAT_H
+#cmakedefine HAVE_TIMEVAL_TV_USEC
+#cmakedefine HAVE_TIMESPEC_TV_NSEC
+#cmakedefine CMAKE_HAVE_PTHREAD_H
+#cmakedefine HAVE_VALGRIND_MEMCHECK_H
+#cmakedefine HAS_RELAXED_CONSTEXPR
+
+#cmakedefine LTO_ENABLED
+#cmakedefine ENABLE_VALGRIND
+#cmakedefine ENABLE_GPROF
+#cmakedefine ENABLE_GCOV
+#cmakedefine ENABLE_ASAN
+
+#cmakedefine01 HAVE_MDBX_VERSIONINFO

src/elements/internals.h

@@ -1023,8 +1023,10 @@ MDBX_INTERNAL_FUNC void mdbx_assert_fail(const MDBX_env *env, const char *msg,
 /* assert(3) variant in transaction context */
 #define mdbx_tassert(txn, expr) mdbx_assert((txn)->mt_env, expr)
 
+#ifndef MDBX_TOOLS /* Avoid using internal mdbx_assert() */
 #undef assert
 #define assert(expr) mdbx_assert(NULL, expr)
+#endif
 
 /*----------------------------------------------------------------------------*/
 /* Internal prototypes */

src/elements/version.c.in

@@ -12,23 +12,29 @@
  * <http://www.OpenLDAP.org/license.html>.
  */
 
-#include "./internals.h"
+#include "elements/internals.h"
 
-#if MDBX_VERSION_MAJOR != 0 || MDBX_VERSION_MINOR != 3
+#if defined(_MSC_VER) && defined(MDBX_BUILD_TARGET)
-#error "API version mismatch!"
+#pragma message("Configuration-depended MDBX_BUILD_TARGET: " MDBX_BUILD_TARGET)
+#endif
+#if defined(_MSC_VER) && defined(MDBX_COMPILE_FLAGS)
+#pragma message(                                                               \
+    "Configuration-depended MDBX_COMPILE_FLAGS: " MDBX_COMPILE_FLAGS)
 #endif
 
-#define MDBX_VERSION_RELEASE 0
+#if MDBX_VERSION_MAJOR != ${MDBX_VERSION_MAJOR} ||                             \
-#define MDBX_VERSION_REVISION 0
+    MDBX_VERSION_MINOR != ${MDBX_VERSION_MINOR}
+#error "API version mismatch! Had `git fetch --tags` done?"
+#endif
 
-/*LIBMDBX_EXPORTS*/ const mdbx_version_info mdbx_version = {
+/*LIBMDBX_API*/ const mdbx_version_info mdbx_version = {
-    MDBX_VERSION_MAJOR,
+    ${MDBX_VERSION_MAJOR},
-    MDBX_VERSION_MINOR,
+    ${MDBX_VERSION_MINOR},
-    MDBX_VERSION_RELEASE,
+    ${MDBX_VERSION_RELEASE},
-    MDBX_VERSION_REVISION,
+    ${MDBX_VERSION_REVISION},
     {"@MDBX_GIT_TIMESTAMP@", "@MDBX_GIT_TREE@", "@MDBX_GIT_COMMIT@",
      "@MDBX_GIT_DESCRIBE@"}};
 
-/*LIBMDBX_EXPORTS*/ const mdbx_build_info mdbx_build = {
+/*LIBMDBX_API*/ const mdbx_build_info mdbx_build = {
-    "@MDBX_BUILD_TIMESTAMP@", "@MDBX_BUILD_TARGET@", "@MDBX_BUILD_OPTIONS@",
+    "@MDBX_BUILD_TIMESTAMP@", ${MDBX_BUILD_TARGET}, "@MDBX_OPTIONS@",
-    "@MDBX_BUILD_COMPILER@", "@MDBX_BUILD_FLAGS@"};
+    "@MDBX_BUILD_COMPILER@", ${MDBX_COMPILE_FLAGS}};

src/tools/CMakeLists.txt

@@ -1,5 +1,3 @@
-project(mdbx_tools)
-
 set(MDBX_TOOLS
   mdbx_chk
   mdbx_copy
@@ -9,11 +7,23 @@ set(MDBX_TOOLS
   )
 
 foreach (TOOL ${MDBX_TOOLS})
-  add_executable(${TOOL} ${TOOL}.c)
+  if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
+    add_executable(${TOOL} ${TOOL}.c wingetopt.c wingetopt.h)
+  else()
+    add_executable(${TOOL} ${TOOL}.c)
+  endif()
+
+  target_link_libraries(${TOOL} mdbx_objects ${CMAKE_THREAD_LIBS_INIT})
+  set_target_properties(${TOOL} PROPERTIES
+    INTERPROCEDURAL_OPTIMIZATION $<BOOL:${INTERPROCEDURAL_OPTIMIZATION}>)
 
-  target_link_libraries(${TOOL} mdbx)
   install(TARGETS ${TOOL} DESTINATION ${CMAKE_INSTALL_PREFIX}/bin COMPONENT mdbx)
   if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${TOOL}.1)
     install(FILES ${TOOL}.1 DESTINATION ${CMAKE_INSTALL_PREFIX}/man/man1 COMPONENT mdbx)
   endif()
 endforeach()
+
+if(LIB_MATH)
+  target_link_libraries(mdbx_chk ${LIB_MATH})
+  target_link_libraries(mdbx_stat ${LIB_MATH})
+endif()

src/tools/mdbx_chk.c

@@ -20,8 +20,7 @@
 #pragma warning(disable : 4996) /* The POSIX name is deprecated... */
 #endif                          /* _MSC_VER (warnings) */
 
-/* Avoid reference to mdbx_runtime_flags from assert() */
+#define MDBX_TOOLS /* Avoid using internal mdbx_assert() */
-#define mdbx_runtime_flags (~0u)
 #include "../elements/internals.h"
 
 typedef struct flagbit {

src/tools/mdbx_copy.c

@@ -20,8 +20,7 @@
 #pragma warning(disable : 4996) /* The POSIX name is deprecated... */
 #endif                          /* _MSC_VER (warnings) */
 
-/* Avoid reference to mdbx_runtime_flags from assert() */
+#define MDBX_TOOLS /* Avoid using internal mdbx_assert() */
-#define mdbx_runtime_flags (~0u)
 #include "../elements/internals.h"
 
 #if defined(_WIN32) || defined(_WIN64)

src/tools/mdbx_dump.c

@@ -20,8 +20,7 @@
 #pragma warning(disable : 4996) /* The POSIX name is deprecated... */
 #endif                          /* _MSC_VER (warnings) */
 
-/* Avoid reference to mdbx_runtime_flags from assert() */
+#define MDBX_TOOLS /* Avoid using internal mdbx_assert() */
-#define mdbx_runtime_flags (~0u)
 #include "../elements/internals.h"
 
 #include <ctype.h>

src/tools/mdbx_load.c

@@ -20,8 +20,7 @@
 #pragma warning(disable : 4996) /* The POSIX name is deprecated... */
 #endif                          /* _MSC_VER (warnings) */
 
-/* Avoid reference to mdbx_runtime_flags from assert() */
+#define MDBX_TOOLS /* Avoid using internal mdbx_assert() */
-#define mdbx_runtime_flags (~0u)
 #include "../elements/internals.h"
 
 #include <ctype.h>

src/tools/mdbx_stat.c

@@ -20,8 +20,7 @@
 #pragma warning(disable : 4996) /* The POSIX name is deprecated... */
 #endif                          /* _MSC_VER (warnings) */
 
-/* Avoid reference to mdbx_runtime_flags from assert() */
+#define MDBX_TOOLS /* Avoid using internal mdbx_assert() */
-#define mdbx_runtime_flags (~0u)
 #include "../elements/internals.h"
 
 #if defined(_WIN32) || defined(_WIN64)

test/CMakeLists.txt

@@ -1,10 +1,29 @@
-set(TARGET mdbx_test)
+list(FIND CMAKE_CXX_COMPILE_FEATURES cxx_std_17 HAS_CXX17)
-project(${TARGET})
+list(FIND CMAKE_CXX_COMPILE_FEATURES cxx_std_14 HAS_CXX14)
+list(FIND CMAKE_CXX_COMPILE_FEATURES cxx_relaxed_constexpr HAS_RELAXED_CONSTEXPR)
+if(NOT DEFINED MDBX_CXX_STANDARD)
+  if(DEFINED CMAKE_CXX_STANDARD)
+    set(MDBX_CXX_STANDARD ${CMAKE_CXX_STANDARD})
+  elseif(NOT HAS_CXX17 LESS 0)
+    set(MDBX_CXX_STANDARD 17)
+  elseif(NOT HAS_CXX14 LESS 0)
+    set(MDBX_CXX_STANDARD 14)
+  else()
+    set(MDBX_CXX_STANDARD 11)
+  endif()
+endif()
+message(STATUS "Use C++${MDBX_CXX_STANDARD} for libmdbx's test")
+if(NOT SUBPROJECT OR NOT DEFINED CMAKE_CXX_STANDARD)
+  set(CMAKE_CXX_STANDARD ${MDBX_CXX_STANDARD})
+endif()
 
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-declarations")
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-cast-qual")
+  set(TEST_OSAL windows)
+else()
+  set(TEST_OSAL unix)
+endif()
 
-add_executable(${TARGET}
+add_executable(mdbx_test
   base.h
   cases.cc
   chrono.cc
@@ -21,7 +40,7 @@ add_executable(${TARGET}
   log.h
   main.cc
   osal.h
-  osal-unix.cc
+  osal-${TEST_OSAL}.cc
   test.cc
   test.h
   try.cc
@@ -31,7 +50,25 @@ add_executable(${TARGET}
   ttl.cc
   )
 
-target_link_libraries(${TARGET}
+set_target_properties(mdbx_test PROPERTIES
-  mdbx
+  INTERPROCEDURAL_OPTIMIZATION $<BOOL:${INTERPROCEDURAL_OPTIMIZATION}>
+  POSITION_INDEPENDENT_CODE ON
+  CXX_STANDARD ${MDBX_CXX_STANDARD}
+  CXX_STANDARD_REQUIRED ON
   )
 
+if(CC_HAS_FASTMATH)
+  target_compile_options(mdbx_test PRIVATE "-ffast-math")
+endif()
+if(CC_HAS_VISIBILITY AND (LTO_ENABLED OR INTERPROCEDURAL_OPTIMIZATION))
+  set_target_properties(mdbx_test PROPERTIES LINK_FLAGS "-fvisibility=hidden")
+endif()
+
+target_link_libraries(mdbx_test mdbx ${LIB_MATH})
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
+  target_link_libraries(mdbx_test winmm.lib)
+endif()
+
+if(UNIX AND NOT SUBPROJECT)
+  add_subdirectory(pcrf)
+endif()

test/base.h

@@ -82,6 +82,7 @@
 
 #define MDBX_INTERNAL_FUNC
 #define MDBX_INTERNAL_VAR extern
+#define MDBX_TOOLS /* Avoid using internal mdbx_assert() */
 #include "../mdbx.h"
 #include "../src/elements/defs.h"
 #include "../src/elements/osal.h"

test/pcrf/CMakeLists.txt

@@ -1,7 +1,5 @@
 set(TARGET pcrf_test)
-project(${TARGET})
-
 add_executable(${TARGET} pcrf_test.c)
-
+target_include_directories(${TARGET} PRIVATE "${PROJECT_SOURCE_DIR}")
 target_link_libraries(${TARGET} mdbx)
 

test/pcrf/pcrf_test.c

@@ -36,7 +36,7 @@
   (int)((addr) >> 24), (int)((addr) >> 16 & 0xff), (int)((addr) >> 8 & 0xff),  \
       (int)((addr)&0xff)
 
-char opt_db_path[PATH_MAX] = "/root/lmdbx_bench2";
+char opt_db_path[PATH_MAX] = "./lmdbx_bench2";
 static MDBX_env *env;
 #define REC_COUNT 10240000
 int64_t ids[REC_COUNT * 10];