Document BOOST_CORE_ALIGNOF

Merge branch 'develop' into feature/alignof
Avoid memory leak in alloc_construct_cxx11_test.cpp, because ASan diagnoses it
2023-01-26 03:01:01 +02:00 · 2023-01-26 02:02:00 +02:00 · 2023-01-26 01:10:00 +02:00 · 2023-01-25 22:00:41 +02:00 · 2023-01-25 21:37:26 +02:00 · 2023-01-25 20:10:31 +02:00
89 changed files with 1665 additions and 330 deletions
--- a/.drone.jsonnet
+++ b/.drone.jsonnet
@@ -0,0 +1,370 @@
+# Copyright 2022 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+local library = "core";
+
+local triggers =
+{
+    branch: [ "master", "develop", "feature/*" ]
+};
+
+local ubsan = { UBSAN: '1', UBSAN_OPTIONS: 'print_stacktrace=1' };
+local asan = { ASAN: '1' };
+
+local linux_pipeline(name, image, environment, packages = "", sources = [], arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "docker",
+    trigger: triggers,
+    platform:
+    {
+        os: "linux",
+        arch: arch
+    },
+    steps:
+    [
+        {
+            name: "everything",
+            image: image,
+            environment: environment,
+            commands:
+            [
+                'set -e',
+                'wget -O - https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add -',
+            ] +
+            (if sources != [] then [ ('apt-add-repository "' + source + '"') for source in sources ] else []) +
+            (if packages != "" then [ 'apt-get update', 'apt-get -y install ' + packages ] else []) +
+            [
+                'export LIBRARY=' + library,
+                './.drone/drone.sh',
+            ]
+        }
+    ]
+};
+
+local macos_pipeline(name, environment, xcode_version = "12.2", osx_version = "catalina", arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "exec",
+    trigger: triggers,
+    platform: {
+        "os": "darwin",
+        "arch": arch
+    },
+    node: {
+        "os": osx_version
+    },
+    steps: [
+        {
+            name: "everything",
+            environment: environment + { "DEVELOPER_DIR": "/Applications/Xcode-" + xcode_version + ".app/Contents/Developer" },
+            commands:
+            [
+                'export LIBRARY=' + library,
+                './.drone/drone.sh',
+            ]
+        }
+    ]
+};
+
+local windows_pipeline(name, image, environment, arch = "amd64") =
+{
+    name: name,
+    kind: "pipeline",
+    type: "docker",
+    trigger: triggers,
+    platform:
+    {
+        os: "windows",
+        arch: arch
+    },
+    "steps":
+    [
+        {
+            name: "everything",
+            image: image,
+            environment: environment,
+            commands:
+            [
+                'cmd /C .drone\\\\drone.bat ' + library,
+            ]
+        }
+    ]
+};
+
+[
+    linux_pipeline(
+        "Linux 14.04 GCC 4.4",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.4', CXXSTD: '98,0x' },
+        "g++-4.4",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.6 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.6', CXXSTD: '98,0x', ADDRMD: '32,64' },
+        "g++-4.6-multilib",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.7 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.7', CXXSTD: '98,0x', ADDRMD: '32,64' },
+        "g++-4.7-multilib",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.8* 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 14.04 GCC 4.9 32/64",
+        "cppalliance/droneubuntu1404:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-4.9', CXXSTD: '03,11', ADDRMD: '32,64' },
+        "g++-4.9-multilib",
+        [ "ppa:ubuntu-toolchain-r/test" ],
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 GCC 5* 32/64",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 6 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-6', CXXSTD: '03,11,14', ADDRMD: '32,64' },
+        "g++-6-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 7* 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 GCC 8 32/64",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-8', CXXSTD: '03,11,14,17', ADDRMD: '32,64' },
+        "g++-8-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* 32/64",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* ARM64",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
+        arch="arm64",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 9* S390x",
+        "cppalliance/droneubuntu2004:multiarch",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a' },
+        arch="s390x",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 GCC 10 32/64",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-10', CXXSTD: '03,11,14,17,20', ADDRMD: '32,64' },
+        "g++-10-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 11* 32/64",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++', CXXSTD: '03,11,14,17,2a', ADDRMD: '32,64' },
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12 32 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '32' } + asan,
+        "g++-12-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 GCC 12 64 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '03,11,14,17,20,2b', ADDRMD: '64' } + asan,
+        "g++-12-multilib",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.5",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.5', CXXSTD: '03,11' },
+        "clang-3.5",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.6",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.6', CXXSTD: '03,11,14' },
+        "clang-3.6",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.7",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.7', CXXSTD: '03,11,14' },
+        "clang-3.7",
+    ),
+
+    linux_pipeline(
+        "Linux 16.04 Clang 3.8",
+        "cppalliance/droneubuntu1604:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.8', CXXSTD: '03,11,14' },
+        "clang-3.8",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 3.9",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-3.9', CXXSTD: '03,11,14' },
+        "clang-3.9",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 4.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-4.0', CXXSTD: '03,11,14' },
+        "clang-4.0",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 5.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-5.0', CXXSTD: '03,11,14,1z' },
+        "clang-5.0",
+    ),
+
+    linux_pipeline(
+        "Linux 18.04 Clang 6.0",
+        "cppalliance/droneubuntu1804:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-6.0', CXXSTD: '03,11,14,17' },
+        "clang-6.0",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 7",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-7', CXXSTD: '03,11,14,17' },
+        "clang-7",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 8",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-8', CXXSTD: '03,11,14,17' },
+        "clang-8",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 9",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-9', CXXSTD: '03,11,14,17,2a' },
+        "clang-9",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 10",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-10', CXXSTD: '03,11,14,17,2a' },
+        "clang-10",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 11",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-11', CXXSTD: '03,11,14,17,2a' },
+        "clang-11",
+    ),
+
+    linux_pipeline(
+        "Linux 20.04 Clang 12",
+        "cppalliance/droneubuntu2004:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-12', CXXSTD: '03,11,14,17,2a' },
+        "clang-12",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 13",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-13', CXXSTD: '03,11,14,17,20' },
+        "clang-13",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 14 UBSAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' } + ubsan,
+        "clang-14",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 14 ASAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', CXXSTD: '03,11,14,17,20,2b' } + asan,
+        "clang-14",
+    ),
+
+    linux_pipeline(
+        "Linux 22.04 Clang 15",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-15', CXXSTD: '03,11,14,17,20,2b' },
+        "clang-15",
+        ["deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy-15 main"],
+    ),
+
+    macos_pipeline(
+        "MacOS 10.15 Xcode 12.2 UBSAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + ubsan,
+    ),
+
+    macos_pipeline(
+        "MacOS 10.15 Xcode 12.2 ASAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + asan,
+    ),
+
+    windows_pipeline(
+        "Windows VS2015 msvc-14.0",
+        "cppalliance/dronevs2015",
+        { TOOLSET: 'msvc-14.0', CXXSTD: '14,latest' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2017 msvc-14.1",
+        "cppalliance/dronevs2017",
+        { TOOLSET: 'msvc-14.1', CXXSTD: '14,17,latest' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2019 msvc-14.2",
+        "cppalliance/dronevs2019",
+        { TOOLSET: 'msvc-14.2', CXXSTD: '14,17,20,latest' },
+    ),
+
+    windows_pipeline(
+        "Windows VS2022 msvc-14.3",
+        "cppalliance/dronevs2022:1",
+        { TOOLSET: 'msvc-14.3', CXXSTD: '14,17,20,latest' },
+    ),
+]
--- a/.drone/drone.bat
+++ b/.drone/drone.bat
@@ -0,0 +1,23 @@
+@REM Copyright 2022 Peter Dimov
+@REM Distributed under the Boost Software License, Version 1.0.
+@REM https://www.boost.org/LICENSE_1_0.txt
+
+@ECHO ON
+
+set LIBRARY=%1
+set DRONE_BUILD_DIR=%CD%
+
+set BOOST_BRANCH=develop
+if "%DRONE_BRANCH%" == "master" set BOOST_BRANCH=master
+cd ..
+git clone -b %BOOST_BRANCH% --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/boostdep
+xcopy /s /e /q %DRONE_BUILD_DIR% libs\%LIBRARY%\
+python tools/boostdep/depinst/depinst.py -I examples %LIBRARY%
+cmd /c bootstrap
+b2 -d0 headers
+
+if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
+if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
+b2 -j3 libs/%LIBRARY%/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
--- a/.drone/drone.sh
+++ b/.drone/drone.sh
@@ -0,0 +1,24 @@
+#!/bin/bash
+
+# Copyright 2022 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+set -ex
+
+DRONE_BUILD_DIR=$(pwd)
+
+BOOST_BRANCH=develop
+if [ "$DRONE_BRANCH" = "master" ]; then BOOST_BRANCH=master; fi
+
+cd ..
+git clone -b $BOOST_BRANCH --depth 1 https://github.com/boostorg/boost.git boost-root
+cd boost-root
+git submodule update --init tools/boostdep
+cp -r $DRONE_BUILD_DIR/* libs/$LIBRARY
+python tools/boostdep/depinst/depinst.py -I examples $LIBRARY
+./bootstrap.sh
+./b2 -d0 headers
+
+echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
+./b2 -j3 libs/$LIBRARY/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${ADDRMD:+address-model=$ADDRMD} ${UBSAN:+undefined-sanitizer=norecover debug-symbols=on} ${ASAN:+address-sanitizer=norecover debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -32,82 +32,95 @@ jobs:
          # Linux, gcc
          - toolset: gcc-4.4
            cxxstd: "98,0x"
+            address-model: 32,64
            os: ubuntu-latest
            container: ubuntu:16.04
            install:
-              - g++-4.4
+              - g++-4.4-multilib
            sources:
              - "ppa:ubuntu-toolchain-r/test"
          - toolset: gcc-4.6
            cxxstd: "03,0x"
+            address-model: 32,64
            os: ubuntu-latest
            container: ubuntu:16.04
            install:
-              - g++-4.6
+              - g++-4.6-multilib
            sources:
              - "ppa:ubuntu-toolchain-r/test"
          - toolset: gcc-4.7
            cxxstd: "03,11"
+            address-model: 32,64
            os: ubuntu-latest
            container: ubuntu:16.04
            install:
-              - g++-4.7
+              - g++-4.7-multilib
          - toolset: gcc-4.8
            cxxstd: "03,11"
+            address-model: 32,64
            os: ubuntu-latest
            container: ubuntu:18.04
            install:
-              - g++-4.8
+              - g++-4.8-multilib
          - toolset: gcc-4.9
            cxxstd: "03,11"
+            address-model: 32,64
            os: ubuntu-latest
            container: ubuntu:16.04
            install:
-              - g++-4.9
+              - g++-4.9-multilib
          - toolset: gcc-5
            cxxstd: "03,11,14,1z"
+            address-model: 32,64
            os: ubuntu-latest
            container: ubuntu:16.04
            install:
-              - g++-5
+              - g++-5-multilib
          - toolset: gcc-6
            cxxstd: "03,11,14,1z"
+            address-model: 32,64
            os: ubuntu-latest
            container: ubuntu:18.04
            install:
-              - g++-6
+              - g++-6-multilib
          - toolset: gcc-7
            cxxstd: "03,11,14,17"
+            address-model: 32,64
            os: ubuntu-latest
            container: ubuntu:18.04
            install:
-              - g++-7
+              - g++-7-multilib
          - toolset: gcc-8
            cxxstd: "03,11,14,17,2a"
+            address-model: 32,64
            os: ubuntu-latest
            container: ubuntu:18.04
            install:
-              - g++-8
+              - g++-8-multilib
          - toolset: gcc-9
            cxxstd: "03,11,14,17,2a"
+            address-model: 32,64
            os: ubuntu-20.04
            install:
-              - g++-9
+              - g++-9-multilib
          - toolset: gcc-10
            cxxstd: "03,11,14,17,20"
+            address-model: 32,64
            os: ubuntu-20.04
            install:
-              - g++-10
+              - g++-10-multilib
          - toolset: gcc-11
            cxxstd: "03,11,14,17,20,23"
+            address-model: 32,64
            os: ubuntu-22.04
            install:
-              - g++-11
+              - g++-11-multilib
          - toolset: gcc-12
            cxxstd: "03,11,14,17,20,23"
+            address-model: 32,64
            os: ubuntu-22.04
            install:
-              - g++-12
+              - g++-12-multilib
          - name: UBSAN
            toolset: gcc-12
            cxxstd: "03,11,14,17,20,23"
@@ -266,6 +279,9 @@ jobs:
          - toolset: clang
            cxxstd: "03,11,14,17,2a"
            os: macos-11
+          - toolset: clang
+            cxxstd: "03,11,14,17,2a"
+            os: macos-12

    timeout-minutes: 120
    runs-on: ${{matrix.os}}
@@ -456,6 +472,10 @@ jobs:
            then
                B2_ARGS+=("cxxflags=${{matrix.cxxflags}}")
            fi
+            if [ -n "${{matrix.address-model}}" ]
+            then
+                B2_ARGS+=("address-model=${{matrix.address-model}}")
+            fi
            if [ -n "${{matrix.linkflags}}" ]
            then
                B2_ARGS+=("linkflags=${{matrix.linkflags}}")
@@ -530,6 +550,7 @@ jobs:
          - os: ubuntu-20.04
          - os: ubuntu-22.04
          - os: macos-11
+          - os: macos-12

    runs-on: ${{matrix.os}}

@@ -576,6 +597,7 @@ jobs:
          - os: ubuntu-20.04
          - os: ubuntu-22.04
          - os: macos-11
+          - os: macos-12

    runs-on: ${{matrix.os}}

@@ -632,6 +654,7 @@ jobs:
          - os: ubuntu-20.04
          - os: ubuntu-22.04
          - os: macos-11
+          - os: macos-12

    runs-on: ${{matrix.os}}

--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -20,6 +20,15 @@ target_link_libraries(boost_core
    Boost::throw_exception
 )

+if(CMAKE_VERSION VERSION_GREATER 3.18 AND CMAKE_GENERATOR MATCHES "Visual Studio")
+
+  file(GLOB_RECURSE boost_core_IDEFILES CONFIGURE_DEPENDS include/*.hpp)
+  source_group(TREE ${PROJECT_SOURCE_DIR}/include FILES ${boost_core_IDEFILES} PREFIX "Header Files")
+  list(APPEND boost_core_IDEFILES extra/boost_core.natvis)
+  target_sources(boost_core PRIVATE ${boost_core_IDEFILES})
+
+endif()
+
 if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")

  add_subdirectory(test)
--- a/appveyor.yml
+++ b/appveyor.yml
@@ -29,6 +29,11 @@ environment:

    # clang-win 32 bit fails to link with "unable to load mspdbcore.dll (error code: 126)"

+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: clang-win
+      ADDRMD: 64
+      CXXSTD: 14,17,latest
+
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      TOOLSET: clang-win
      ADDRMD: 64
@@ -59,6 +64,13 @@ environment:
      TOOLSET: gcc
      CXXSTD: 03,11,14,1z

+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      CMAKE: 1
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      CMAKE_SUBDIR: 1
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
+      CMAKE_INSTALL: 1
+
 install:
  - set GIT_FETCH_JOBS=8
  - set BOOST_BRANCH=develop
@@ -70,7 +82,7 @@ install:
  - xcopy /s /e /q %APPVEYOR_BUILD_FOLDER% libs\core\
  - python tools/boostdep/depinst/depinst.py --git_args "--jobs %GIT_FETCH_JOBS%" core
  - cmd /c bootstrap
-  - b2 headers
+  - b2 -d0 headers

 build: off

@@ -78,4 +90,27 @@ test_script:
  - PATH=%ADDPATH%%PATH%
  - if not "%CXXSTD%" == "" set CXXSTD=cxxstd=%CXXSTD%
  - if not "%ADDRMD%" == "" set ADDRMD=address-model=%ADDRMD%
-  - b2 -j %NUMBER_OF_PROCESSORS% libs/core/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
+  - if "%CMAKE%%CMAKE_SUBDIR%%CMAKE_INSTALL%" == ""  b2 -j %NUMBER_OF_PROCESSORS% libs/core/test toolset=%TOOLSET% %CXXSTD% %ADDRMD% variant=debug,release embed-manifest-via=linker
+
+  - if not "%CMAKE%" == ""  mkdir __build__ && cd __build__
+  - if not "%CMAKE%" == ""  cmake -DBUILD_TESTING=ON -DBOOST_INCLUDE_LIBRARIES=core ..
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config Debug & ctest --output-on-failure --no-tests=error -j 3 -C Debug
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config Release & ctest --output-on-failure --no-tests=error -j 3 -C Release
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config MinSizeRel & ctest --output-on-failure --no-tests=error -j 3 -C MinSizeRel
+  - if not "%CMAKE%" == ""  cmake --build . --target tests -j 3 --config RelWithDebInfo & ctest --output-on-failure --no-tests=error -j 3 -C RelWithDebInfo
+
+  - if not "%CMAKE_SUBDIR%" == ""  cd libs/core/test/cmake_subdir_test && mkdir __build__ && cd __build__
+  - if not "%CMAKE_SUBDIR%" == ""  cmake ..
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config Debug && cmake --build . --target check --config Debug
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config Release && cmake --build . --target check --config Release
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config MinSizeRel && cmake --build . --target check --config MinSizeRel
+  - if not "%CMAKE_SUBDIR%" == ""  cmake --build . --config RelWithDebInfo && cmake --build . --target check --config RelWithDebInfo
+
+  - if not "%CMAKE_INSTALL%" == ""  mkdir __build__ && cd __build__
+  - if not "%CMAKE_INSTALL%" == ""  cmake -DBOOST_INCLUDE_LIBRARIES=core -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --target install --config Debug
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --target install --config Release
+  - if not "%CMAKE_INSTALL%" == ""  cd ../libs/core/test/cmake_install_test && mkdir __build__ && cd __build__
+  - if not "%CMAKE_INSTALL%" == ""  cmake -DCMAKE_INSTALL_PREFIX=C:/cmake-prefix ..
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --config Debug && cmake --build . --target check --config Debug
+  - if not "%CMAKE_INSTALL%" == ""  cmake --build . --config Release && cmake --build . --target check --config Release
--- a/doc/alignof.qbk
+++ b/doc/alignof.qbk
@@ -0,0 +1,33 @@
+[/
+  Copyright 2023 Peter Dimov
+  Distributed under the Boost Software License, Version 1.0.
+  https://boost.org/LICENSE_1_0.txt
+]
+
+[section:alignof alignof]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/alignof.hpp>]
+
+The header `<boost/core/alignof.hpp>` defines the macro `BOOST_CORE_ALIGNOF`,
+a portable equivalent of the `alignof` operator from C++11.
+
+[section Example]
+
+``
+#include <boost/core/alignof.hpp>
+#include <cstddef>
+
+constexpr std::size_t alignment_of_double = BOOST_CORE_ALIGNOF(double);
+``
+
+[endsect]
+
+[endsect]
+
+[endsect]
--- a/doc/changes.qbk
+++ b/doc/changes.qbk
@@ -1,11 +1,26 @@
 [/
  Copyright 2021 Peter Dimov
+  Copyright 2022 Andrey Semashev
  Distributed under the Boost Software License, Version 1.0.
  https://boost.org/LICENSE_1_0.txt)
 ]

 [section Revision History]

+[section Changes in 1.82.0]
+
+* Added [link core.snprintf `boost/core/snprintf.hpp`] header with portable definitions of `snprintf`, `vsnprintf` and
+  their `wchar_t` counterparts.
+* Deprecated `boost/core/is_same.hpp` and `boost::core::is_same`. The header will be removed in a future release.
+  Users are advised to use [@http://www.boost.org/doc/libs/release/libs/type_traits/doc/html/index.html Boost.TypeTraits]
+  or C++ standard library type traits instead.
+* Marked `boost::ref` member functions and associated methods with `noexcept`.
+* Marked `boost::swap` function with `noexcept`, depending on whether the type supports a non-throwing swap operation.
+* Added `boost::core::launder`, a portable implementation of `std::launder`.
+* Added `BOOST_CORE_ALIGNOF`, a portable implementation of `alignof`.
+
+[endsect]
+
 [section Changes in 1.81.0]

 * [link core.empty_value `empty_value`] members are now marked as `constexpr`.
--- a/doc/core.qbk
+++ b/doc/core.qbk
@@ -41,6 +41,7 @@ criteria for inclusion is that the utility component be:
 [include changes.qbk]

 [include addressof.qbk]
+[include alignof.qbk]
 [include allocator_access.qbk]
 [include allocator_traits.qbk]
 [include bit.qbk]
@@ -55,6 +56,7 @@ criteria for inclusion is that the utility component be:
 [include first_scalar.qbk]
 [include ignore_unused.qbk]
 [include is_same.qbk]
+[include launder.qbk]
 [include lightweight_test.qbk]
 [include no_exceptions_support.qbk]
 [include noinit_adaptor.qbk]
@@ -70,6 +72,7 @@ criteria for inclusion is that the utility component be:
 [include swap.qbk]
 [include typeinfo.qbk]
 [include type_name.qbk]
+[include snprintf.qbk]
 [include uncaught_exceptions.qbk]
 [include use_default.qbk]
 [include verbose_terminate_handler.qbk]
--- a/doc/is_same.qbk
+++ b/doc/is_same.qbk
@@ -17,6 +17,11 @@

 [section Header <boost/core/is_same.hpp>]

+[warning This component is deprecated and will be removed in a future release.
+Users are recommended to use `boost::is_same` from
+[@http://www.boost.org/doc/libs/release/libs/type_traits/doc/html/index.html Boost.TypeTraits]
+or `std::is_same` from C++ standard library `<type_traits>` instead.]
+
 The header `<boost/core/is_same.hpp>` defines the class template
 `boost::core::is_same<T1,T2>`. It defines a nested integral constant
 `value` which is `true` when `T1` and `T2` are the same type, and
--- a/doc/launder.qbk
+++ b/doc/launder.qbk
@@ -0,0 +1,39 @@
+[/
+  Copyright 2023 Peter Dimov
+  Distributed under the Boost Software License, Version 1.0.
+  https://boost.org/LICENSE_1_0.txt
+]
+
+[section:launder launder]
+
+[simplesect Authors]
+
+* Peter Dimov
+
+[endsimplesect]
+
+[section Header <boost/core/launder.hpp>]
+
+The header `<boost/core/launder.hpp>` defines the function
+`void boost::core::launder()`, a portable implementation of
+`std::launder`.
+
+[section Synopsis]
+
+``
+namespace boost
+{
+namespace core
+{
+
+template<class T> T* launder( T* p );
+
+} // namespace core
+} // namespace boost
+``
+
+[endsect]
+
+[endsect]
+
+[endsect]
--- a/doc/lightweight_test.qbk
+++ b/doc/lightweight_test.qbk
@@ -51,8 +51,16 @@ When using `lightweight_test.hpp`, *do not forget* to

 namespace boost
 {
-    int report_errors();
-}
+
+int report_errors();
+
+namespace core
+{
+
+void lwt_init();
+
+} // namespace core
+} // namespace boost
 ``

 [endsect]
@@ -246,6 +254,25 @@ Return the error count from `main`.

 [endsect]

+[section lwt_init]
+
+``
+void boost::core::lwt_init()
+``
+
+Performs one-time initialization. Disables the interactive message
+boxes displayed by the Microsoft Windows debug runtime library on
+`abort`, failing `assert`, and other abnormal program terminations
+(to facilitate unattended testing), and ensures that in case
+`boost::report_errors` is not called (a common mistake), the program
+ends with a nonzero exit code.
+
+`lwt_init` is automatically called by the test macros. There is
+no need to call it explicitly, except in cases where a test fails due
+to e.g. an assertion failure before the first test macro is invoked.
+
+[endsect]
+
 [section Example]

 ``
@@ -326,14 +353,14 @@ parentheses.)

 ``
 #include <boost/core/lightweight_test_trait.hpp>
-#include <boost/core/is_same.hpp>
+#include <boost/type_traits/is_same.hpp>

 template<class T, class U> struct X
 {
    typedef T type;
 };

-using boost::core::is_same;
+using boost::is_same;

 int main()
 {
--- a/doc/snprintf.qbk
+++ b/doc/snprintf.qbk
@@ -0,0 +1,47 @@
+[/
+ / Copyright (c) 2022 Andrey Semashev
+ /
+ / Distributed under the Boost Software License, Version 1.0. (See accompanying
+ / file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+ /]
+
+[section:snprintf snprintf]
+
+[simplesect Authors]
+
+* Andrey Semashev
+
+[endsimplesect]
+
+[section Header <boost/core/snprintf.hpp>]
+
+The header `<boost/core/snprintf.hpp>` provides portable definition of [@https://en.cppreference.com/w/c/io/fprintf `snprintf`],
+`vsnprintf` and their corresponding `wchar_t` counterparts. On a platform that supports these functions in the standard library,
+these definitions are equivalent to the standard functions. On other platforms (mainly, older MSVC versions) these functions
+are emulated through non-standard functions that have similar behavior.
+
+Depending on the standard library, certain implementation differences are exposed to the user:
+
+* Any non-standard behavior with respect to string format description are not hidden by the emulation.
+* Returned value of `boost::core::snprintf` in case if the output buffer is too small may not be equal to the number of characters
+  that would have been written if the buffer was large enough. It is, however, equal or larger than the buffer size,
+  which still allows the caller to detect the buffer overflow condition. The formatted output is still properly null-terminated
+  in this case.
+
+[note Unlike `snprintf`, `swprintf` does not return the number of characters to be written if the output buffer is too small
+but returns -1 instead. Furthermore, `swprintf` may or may not produce characters in the output buffer in this case.]
+
+[section Example]
+``
+char buf[10];
+int n = boost::core::snprintf(buf, sizeof(buf), "%d", i);
+if (n < 0)
+    throw std::runtime_error("Formatting error");
+if (n >= sizeof(buf))
+    throw std::runtime_error("Formatting buffer overflow");
+``
+[endsect]
+
+[endsect]
+
+[endsect]
--- a/doc/swap.qbk
+++ b/doc/swap.qbk
@@ -22,7 +22,7 @@

 [section Header <boost/core/swap.hpp>]

-`template<class T> void swap(T& left, T& right);`
+[^template<class T> void swap(T& left, T& right) noexcept(['see below]);]

 [endsect]

@@ -40,13 +40,14 @@ specialized swap function is available, `std::swap` is used.
 The generic `std::swap` function requires that the elements
 to be swapped are assignable and copy constructible. It is
 usually implemented using one copy construction and two
-assignments - this is often both unnecessarily restrictive and
-unnecessarily slow. In addition, where the generic swap
-implementation provides only the basic guarantee, specialized
-swap functions are often able to provide the no-throw exception
-guarantee (and it is considered best practice to do so where
-possible [footnote Scott Meyers, Effective C++ Third Edition,
-Item 25: "Consider support for a non-throwing swap"].
+assignments (C++11 replaces copy operations with move) - this
+is often both unnecessarily restrictive and unnecessarily slow.
+In addition, where the generic swap implementation provides
+only the basic guarantee, specialized swap functions are often
+able to provide the no-throw exception guarantee (and it is
+considered best practice to do so where possible[footnote Scott
+Meyers, Effective C++ Third Edition, Item 25: "Consider support
+for a non-throwing swap"].

 The alternative to using argument dependent lookup in this
 situation is to provide a template specialization of
@@ -59,12 +60,12 @@ in their own namespaces.
 `std::swap` originally did not do so, but a request to add an
 overload of `std::swap` for built-in arrays has been accepted
 by the C++ Standards Committee[footnote
-  [@http://open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809 
+  [@http://open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#809
  LWG Defect Report 809: std::swap should be overloaded for array
  types]].

 [endsect]
-    
+
 [section Exception Safety]

 `boost::swap` provides the same exception guarantee as the
@@ -73,30 +74,33 @@ of type `T[n]`, where `n > 1` and the underlying swap function
 for `T` provides the strong exception guarantee, `boost::swap`
 provides only the basic exception guarantee.

+In C++11 and later, `boost::swap` propagates the same `noexcept`
+specification as the one specified in the underlying swap function.
+
 [endsect]

 [section Requirements]

 Either:

-* T must be assignable
-* T must be copy constructible
+* `T` must be copy assignable (/since C++11:/ move assignable)
+* `T` must be copy constructible (/since C++11:/ move constructible)

 Or:

-* A function with the signature `swap(T&,T&)` is available via
+* A function with the signature `swap(T&, T&)` is available via
  argument dependent lookup

 Or:

-* A template specialization of `std::swap` exists for T
+* A template specialization of `std::swap` exists for `T`

 Or:

-* T is a built-in array of swappable elements
+* `T` is a built-in array of swappable elements

 [endsect]
-    
+
 [section Portability]

 Several older compilers do not support argument dependent
@@ -104,11 +108,11 @@ lookup. On these compilers `boost::swap` will call
 `std::swap`, ignoring any specialized swap functions that
 could be found as a result of argument dependent lookup.

-[endsect]    
+[endsect]

 [section Credits]

-* *Niels Dekker* - for implementing and documenting support for 
+* *Niels Dekker* - for implementing and documenting support for
  built-in arrays
 * *Joseph Gauterin* - for the initial idea, implementation,
  tests, and documentation
--- a/extra/boost_core.natvis
+++ b/extra/boost_core.natvis
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+
+  <Type Name="boost::core::basic_string_view&lt;*&gt;">
+    <DisplayString>{p_,[n_]s}</DisplayString>
+  </Type>
+
+</AutoVisualizer>
--- a/include/boost/core/alignof.hpp
+++ b/include/boost/core/alignof.hpp
@@ -0,0 +1,57 @@
+#ifndef BOOST_CORE_MAX_ALIGN_HPP_INCLUDED
+#define BOOST_CORE_MAX_ALIGN_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  Copyright 2023 Peter Dimov
+//  Distributed under the Boost Software License, Version 1.0.
+//  https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+#include <cstddef>
+
+#if !defined(BOOST_NO_CXX11_ALIGNOF)
+
+#define BOOST_CORE_ALIGNOF alignof
+
+#elif defined(__GNUC__)
+
+#define BOOST_CORE_ALIGNOF __alignof__
+
+#elif defined(_MSC_VER)
+
+#define BOOST_CORE_ALIGNOF __alignof
+
+#else
+
+namespace boost
+{
+namespace core
+{
+namespace detail
+{
+
+template<class T> struct alignof_helper
+{
+    char x;
+    T t;
+};
+
+} // namespace detail
+} // namespace core
+} // namespace boost
+
+#if defined(__GNUC__)
+// ignoring -Wvariadic-macros with #pragma doesn't work under GCC
+# pragma GCC system_header
+#endif
+
+#define BOOST_CORE_ALIGNOF(...) offsetof( ::boost::core::detail::alignof_helper<__VA_ARGS__>, t );
+
+#endif
+
+#endif  // #ifndef BOOST_CORE_MAX_ALIGN_HPP_INCLUDED
--- a/include/boost/core/allocator_access.hpp
+++ b/include/boost/core/allocator_access.hpp
@@ -807,14 +807,14 @@ using allocator_rebind_t = typename allocator_rebind<A, T>::type;

 } /* boost */

-#if defined(_LIBCPP_SUPPRESS_DEPRECATED_POP)
-_LIBCPP_SUPPRESS_DEPRECATED_POP
+#if defined(_MSC_VER)
+#pragma warning(pop)
 #endif
 #if defined(_STL_RESTORE_DEPRECATED_WARNING)
 _STL_RESTORE_DEPRECATED_WARNING
 #endif
-#if defined(_MSC_VER)
-#pragma warning(pop)
+#if defined(_LIBCPP_SUPPRESS_DEPRECATED_POP)
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 #endif

 #endif
--- a/include/boost/core/detail/is_same.hpp
+++ b/include/boost/core/detail/is_same.hpp
@@ -0,0 +1,39 @@
+#ifndef BOOST_CORE_DETAIL_IS_SAME_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_IS_SAME_HPP_INCLUDED
+
+// is_same<T1,T2>::value is true when T1 == T2
+//
+// Copyright 2014 Peter Dimov
+//
+// Distributed under the Boost Software License, Version 1.0.
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+namespace boost
+{
+namespace core
+{
+namespace detail
+{
+
+template< class T1, class T2 > struct is_same
+{
+    BOOST_STATIC_CONSTANT( bool, value = false );
+};
+
+template< class T > struct is_same< T, T >
+{
+    BOOST_STATIC_CONSTANT( bool, value = true );
+};
+
+} // namespace detail
+} // namespace core
+} // namespace boost
+
+#endif // #ifndef BOOST_CORE_DETAIL_IS_SAME_HPP_INCLUDED
--- a/include/boost/core/detail/lwt_unattended.hpp
+++ b/include/boost/core/detail/lwt_unattended.hpp
@@ -0,0 +1,62 @@
+#ifndef BOOST_CORE_DETAIL_LWT_UNATTENDED_HPP_INCLUDED
+#define BOOST_CORE_DETAIL_LWT_UNATTENDED_HPP_INCLUDED
+
+// Copyright 2014, 2022 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <cstdlib>
+#if defined(_MSC_VER) && defined(_CPPLIB_VER) && defined(_DEBUG)
+# include <crtdbg.h>
+#endif
+
+namespace boost
+{
+namespace core
+{
+namespace detail
+{
+
+// Setup unattended mode by disabling interactive popups on
+// assertion failures
+
+inline void lwt_unattended()
+{
+#if defined(_MSC_VER) && (_MSC_VER > 1310)
+
+    // disable message boxes on assert(), abort()
+    ::_set_abort_behavior( 0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT );
+
+# pragma warning(push)
+# pragma warning(disable: 4996)
+
+# if defined(__clang__)
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wdeprecated-declarations"
+# endif
+
+    // disable message box on crash
+    ::_seterrormode( /*SEM_NOGPFAULTERRORBOX*/ 0x0002 );
+
+# if defined(__clang__)
+#  pragma clang diagnostic pop
+# endif
+
+# pragma warning(pop)
+
+#endif
+
+#if defined(_MSC_VER) && defined(_CPPLIB_VER) && defined(_DEBUG)
+
+    // disable message boxes on iterator debugging violations
+    _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
+    _CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
+
+#endif
+}
+
+} // namespace detail
+} // namespace core
+} // namespace boost
+
+#endif // #ifndef BOOST_CORE_DETAIL_LWT_UNATTENDED_HPP_INCLUDED
--- a/include/boost/core/detail/string_view.hpp
+++ b/include/boost/core/detail/string_view.hpp
@@ -14,7 +14,7 @@
 // https://www.boost.org/LICENSE_1_0.txt

 #include <boost/core/enable_if.hpp>
-#include <boost/core/is_same.hpp>
+#include <boost/core/detail/is_same.hpp>
 #include <boost/assert.hpp>
 #include <boost/assert/source_location.hpp>
 #include <boost/throw_exception.hpp>
@@ -381,7 +381,7 @@ public:
    }

    template<class End> BOOST_CXX14_CONSTEXPR basic_string_view( Ch const* first, End last,
-        typename boost::enable_if<is_same<End, Ch const*> >::type* = 0 ) BOOST_NOEXCEPT: p_( first ), n_( last - first )
+        typename boost::enable_if<boost::core::detail::is_same<End, Ch const*> >::type* = 0 ) BOOST_NOEXCEPT: p_( first ), n_( last - first )
    {
        BOOST_ASSERT( last - first >= 0 );
    }
@@ -399,7 +399,7 @@ public:
 #endif

    template<class Ch2> basic_string_view( boost::basic_string_view<Ch2, std::char_traits<Ch2> > const& str,
-        typename boost::enable_if<is_same<Ch, Ch2> >::type* = 0 ) BOOST_NOEXCEPT: p_( str.data() ), n_( str.size() )
+        typename boost::enable_if<boost::core::detail::is_same<Ch, Ch2> >::type* = 0 ) BOOST_NOEXCEPT: p_( str.data() ), n_( str.size() )
    {
    }

@@ -430,7 +430,7 @@ public:

 #if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)

-    template<class Ch2, class En = typename boost::enable_if<is_same<Ch2, Ch> >::type>
+    template<class Ch2, class En = typename boost::enable_if<boost::core::detail::is_same<Ch2, Ch> >::type>
    operator std::basic_string_view<Ch2>() const BOOST_NOEXCEPT
    {
        return std::basic_string_view<Ch>( data(), size() );
@@ -439,7 +439,7 @@ public:
 #endif

    template<class Ch2> operator boost::basic_string_view<Ch2,
-        typename boost::enable_if<boost::core::is_same<Ch2, Ch>, std::char_traits<Ch> >::type> () const BOOST_NOEXCEPT
+        typename boost::enable_if<boost::core::detail::is_same<Ch2, Ch>, std::char_traits<Ch> >::type> () const BOOST_NOEXCEPT
    {
        return boost::basic_string_view< Ch, std::char_traits<Ch> >( data(), size() );
    }
@@ -605,7 +605,7 @@ public:
        if( cmp != 0 ) return cmp;

        if( size() == str.size() ) return 0;
-        
+
        return size() < str.size()? -1: +1;
    }

--- a/include/boost/core/is_same.hpp
+++ b/include/boost/core/is_same.hpp
@@ -1,12 +1,6 @@
 #ifndef BOOST_CORE_IS_SAME_HPP_INCLUDED
 #define BOOST_CORE_IS_SAME_HPP_INCLUDED

-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
 // is_same<T1,T2>::value is true when T1 == T2
 //
 // Copyright 2014 Peter Dimov
@@ -16,6 +10,15 @@
 // http://www.boost.org/LICENSE_1_0.txt

 #include <boost/config.hpp>
+#include <boost/core/detail/is_same.hpp>
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
+#include <boost/config/header_deprecated.hpp>
+
+BOOST_HEADER_DEPRECATED("<boost/type_traits/is_same.hpp>")

 namespace boost
 {
@@ -23,15 +26,7 @@ namespace boost
 namespace core
 {

-template< class T1, class T2 > struct is_same
-{
-    BOOST_STATIC_CONSTANT( bool, value = false );
-};
-
-template< class T > struct is_same< T, T >
-{
-    BOOST_STATIC_CONSTANT( bool, value = true );
-};
+using boost::core::detail::is_same;

 } // namespace core

--- a/include/boost/core/launder.hpp
+++ b/include/boost/core/launder.hpp
@@ -0,0 +1,55 @@
+#ifndef BOOST_CORE_LAUNDER_HPP_INCLUDED
+#define BOOST_CORE_LAUNDER_HPP_INCLUDED
+
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+//  Copyright 2023 Peter Dimov
+//  Distributed under the Boost Software License, Version 1.0.
+//  https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(__has_builtin)
+# if __has_builtin(__builtin_launder)
+#  define BOOST_CORE_HAS_BUILTIN_LAUNDER
+# endif
+#endif
+
+#if (__cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)) && !defined(BOOST_CORE_HAS_BUILTIN_LAUNDER)
+# include <new>
+#endif
+
+namespace boost
+{
+namespace core
+{
+
+#if defined(BOOST_CORE_HAS_BUILTIN_LAUNDER)
+
+template<class T> T* launder( T* p )
+{
+    return __builtin_launder( p );
+}
+
+#elif (__cplusplus >= 201703L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)) && defined(__cpp_lib_launder)
+
+template<class T> T* launder( T* p )
+{
+    return std::launder( p );
+}
+
+#else
+
+template<class T> T* launder( T* p )
+{
+    return p;
+}
+
+#endif
+
+} // namespace core
+} // namespace boost
+
+#endif  // #ifndef BOOST_CORE_LAUNDER_HPP_INCLUDED
--- a/include/boost/core/lightweight_test.hpp
+++ b/include/boost/core/lightweight_test.hpp
@@ -22,6 +22,7 @@
 //  http://www.boost.org/LICENSE_1_0.txt
 //

+#include <boost/core/detail/lwt_unattended.hpp>
 #include <boost/current_function.hpp>
 #include <boost/config.hpp>
 #include <exception>
@@ -32,11 +33,6 @@
 #include <cstring>
 #include <cstddef>
 #include <cctype>
-#include <cstdio>
-
-#if defined(_MSC_VER) && defined(_CPPLIB_VER) && defined(_DEBUG)
-# include <crtdbg.h>
-#endif

 //  IDE's like Visual Studio perform better if output goes to std::cout or
 //  some other stream, so allow user to configure output stream:
@@ -46,42 +42,39 @@

 namespace boost
 {
-
 namespace detail
 {

-class test_result {
+class test_result
+{
 public:
-    test_result()
-        : report_(false)
-        , errors_(0) {
-#if defined(_MSC_VER) && (_MSC_VER > 1310)
-        // disable message boxes on assert(), abort()
-        ::_set_abort_behavior(0, _WRITE_ABORT_MSG | _CALL_REPORTFAULT);
-#endif
-#if defined(_MSC_VER) && defined(_CPPLIB_VER) && defined(_DEBUG)
-        // disable message boxes on iterator debugging violations
-        _CrtSetReportMode( _CRT_ASSERT, _CRTDBG_MODE_FILE );
-        _CrtSetReportFile( _CRT_ASSERT, _CRTDBG_FILE_STDERR );
-#endif
+
+    test_result(): report_( false ), errors_( 0 )
+    {
+        core::detail::lwt_unattended();
    }

-    ~test_result() {
-        if (!report_) {
+    ~test_result()
+    {
+        if( !report_ )
+        {
            BOOST_LIGHTWEIGHT_TEST_OSTREAM << "main() should return report_errors()" << std::endl;
            std::abort();
        }
    }

-    int& errors() {
+    int& errors()
+    {
        return errors_;
    }

-    void done() {
+    void done()
+    {
        report_ = true;
    }

 private:
+
    bool report_;
    int errors_;
 };
@@ -197,18 +190,6 @@ inline unsigned long test_output_impl( char16_t const& v ) { return v; }
 inline unsigned long test_output_impl( char32_t const& v ) { return v; }
 #endif

-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable: 4996)
-#endif
-
-// Use snprintf if available as some compilers (clang 14.0) issue deprecation warnings for sprintf
-#if ( defined(_MSC_VER) && _MSC_VER < 1900 ) || ( defined(__MINGW32__) && !defined(__MINGW64_VERSION_MAJOR) )
-# define BOOST_CORE_DETAIL_SNPRINTF(buffer, format, arg) std::sprintf(buffer, format, arg)
-#else
-# define BOOST_CORE_DETAIL_SNPRINTF(buffer, format, arg) std::snprintf(buffer, sizeof(buffer)/sizeof(buffer[0]), format, arg)
-#endif
-
 inline std::string test_output_impl( char const& v )
 {
    if( std::isprint( static_cast<unsigned char>( v ) ) )
@@ -217,19 +198,17 @@ inline std::string test_output_impl( char const& v )
    }
    else
    {
-        char buffer[ 8 ];
-        BOOST_CORE_DETAIL_SNPRINTF( buffer, "\\x%02X", static_cast<unsigned char>( v ) );
+        static const char char_table[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
+        char buffer[ 4 ];
+        buffer[ 0 ] = '\\';
+        buffer[ 1 ] = 'x';
+        buffer[ 2 ] = char_table[ (static_cast<unsigned char>( v ) >> 4u) & 0x0f ];
+        buffer[ 3 ] = char_table[ static_cast<unsigned char>( v ) & 0x0f ];

-        return buffer;
+        return std::string( buffer, 4u );
    }
 }

-#undef BOOST_CORE_DETAIL_SNPRINTF
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
-
 // predicates

 struct lw_test_eq
@@ -539,6 +518,15 @@ inline int report_errors()
    return errors < 256? errors: 255;
 }

+namespace core
+{
+
+inline void lwt_init()
+{
+    boost::detail::test_results();
+}
+
+} // namespace core
 } // namespace boost

 #define BOOST_TEST(expr) ( ::boost::detail::test_impl(#expr, __FILE__, __LINE__, BOOST_CURRENT_FUNCTION, (expr)? true: false) )
--- a/include/boost/core/lightweight_test_trait.hpp
+++ b/include/boost/core/lightweight_test_trait.hpp
@@ -22,7 +22,7 @@

 #include <boost/core/lightweight_test.hpp>
 #include <boost/core/type_name.hpp>
-#include <boost/core/is_same.hpp>
+#include <boost/core/detail/is_same.hpp>
 #include <boost/config.hpp>

 namespace boost
@@ -56,7 +56,7 @@ template<class T> inline bool test_trait_same_impl_( T )
 }

 template<class T1, class T2> inline void test_trait_same_impl( char const * types,
-  boost::core::is_same<T1, T2> same, char const * file, int line, char const * function )
+  boost::core::detail::is_same<T1, T2> same, char const * file, int line, char const * function )
 {
    if( test_trait_same_impl_( same ) )
    {
@@ -86,6 +86,6 @@ template<class T1, class T2> inline void test_trait_same_impl( char const * type
 # pragma GCC system_header
 #endif

-#define BOOST_TEST_TRAIT_SAME(...) ( ::boost::detail::test_trait_same_impl(#__VA_ARGS__, ::boost::core::is_same<__VA_ARGS__>(), __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )
+#define BOOST_TEST_TRAIT_SAME(...) ( ::boost::detail::test_trait_same_impl(#__VA_ARGS__, ::boost::core::detail::is_same< __VA_ARGS__ >(), __FILE__, __LINE__, BOOST_CURRENT_FUNCTION) )

 #endif // #ifndef BOOST_CORE_LIGHTWEIGHT_TEST_TRAIT_HPP
--- a/include/boost/core/ref.hpp
+++ b/include/boost/core/ref.hpp
@@ -1,17 +1,15 @@
 #ifndef BOOST_CORE_REF_HPP
 #define BOOST_CORE_REF_HPP

-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
 #include <boost/core/addressof.hpp>
 #include <boost/core/enable_if.hpp>

+#if defined(BOOST_HAS_PRAGMA_ONCE)
+# pragma once
+#endif
+
 //
 //  ref.hpp - ref/cref, useful helper functions
 //
@@ -61,9 +59,11 @@ template< class Y, class T > struct ref_convertible
    enum _vt { value = sizeof( (f)( static_cast<Y*>(0) ) ) == sizeof(yes) };
 };

+#if defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
 struct ref_empty
 {
 };
+#endif

 } // namespace detail

@@ -92,11 +92,11 @@ public:

     @remark Does not throw.
    */
-    BOOST_FORCEINLINE explicit reference_wrapper(T& t): t_(boost::addressof(t)) {}
+    BOOST_FORCEINLINE explicit reference_wrapper(T& t) BOOST_NOEXCEPT : t_(boost::addressof(t)) {}

 #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )

-    BOOST_FORCEINLINE explicit reference_wrapper( T & t, ref_workaround_tag ): t_( boost::addressof( t ) ) {}
+    BOOST_FORCEINLINE explicit reference_wrapper( T & t, ref_workaround_tag ) BOOST_NOEXCEPT : t_( boost::addressof( t ) ) {}

 #endif

@@ -117,30 +117,37 @@ public:
     @remark Only enabled when `Y*` is convertible to `T*`.
     @remark Does not throw.
    */
-    template<class Y> reference_wrapper( reference_wrapper<Y> r,
-        typename enable_if_c<boost::detail::ref_convertible<Y, T>::value,
-            boost::detail::ref_empty>::type = boost::detail::ref_empty() ): t_( r.t_ )
+#if !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+    template<class Y, class = typename enable_if_c<boost::detail::ref_convertible<Y, T>::value>::type>
+    reference_wrapper( reference_wrapper<Y> r ) BOOST_NOEXCEPT : t_( r.t_ )
    {
    }
+#else
+    template<class Y> reference_wrapper( reference_wrapper<Y> r,
+        typename enable_if_c<boost::detail::ref_convertible<Y, T>::value,
+            boost::detail::ref_empty>::type = boost::detail::ref_empty() ) BOOST_NOEXCEPT : t_( r.t_ )
+    {
+    }
+#endif

    /**
     @return The stored reference.
     @remark Does not throw.
    */
-    BOOST_FORCEINLINE operator T& () const { return *t_; }
+    BOOST_FORCEINLINE operator T& () const BOOST_NOEXCEPT { return *t_; }

    /**
     @return The stored reference.
     @remark Does not throw.
    */
-    BOOST_FORCEINLINE T& get() const { return *t_; }
+    BOOST_FORCEINLINE T& get() const BOOST_NOEXCEPT { return *t_; }

    /**
     @return A pointer to the object referenced by the stored
       reference.
     @remark Does not throw.
    */
-    BOOST_FORCEINLINE T* get_pointer() const { return t_; }
+    BOOST_FORCEINLINE T* get_pointer() const BOOST_NOEXCEPT { return t_; }

 private:

@@ -165,7 +172,7 @@ private:
 @return `reference_wrapper<T>(t)`
 @remark Does not throw.
 */
-template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T & t )
+template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T & t ) BOOST_NOEXCEPT
 {
 #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )

@@ -184,7 +191,7 @@ template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T
 @return `reference_wrapper<T const>(t)`
 @remark Does not throw.
 */
-template<class T> BOOST_FORCEINLINE reference_wrapper<T const> BOOST_REF_CONST cref( T const & t )
+template<class T> BOOST_FORCEINLINE reference_wrapper<T const> BOOST_REF_CONST cref( T const & t ) BOOST_NOEXCEPT
 {
    return reference_wrapper<T const>(t);
 }
@@ -315,7 +322,7 @@ template<typename T> struct unwrap_reference< reference_wrapper<T> const volatil
 @return `unwrap_reference<T>::type&(t)`
 @remark Does not throw.
 */
-template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_ref( T & t )
+template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_ref( T & t ) BOOST_NOEXCEPT
 {
    return t;
 }
@@ -325,7 +332,7 @@ template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_r
 /**
 @cond
 */
-template<class T> BOOST_FORCEINLINE T* get_pointer( reference_wrapper<T> const & r )
+template<class T> BOOST_FORCEINLINE T* get_pointer( reference_wrapper<T> const & r ) BOOST_NOEXCEPT
 {
    return r.get_pointer();
 }
--- a/include/boost/core/snprintf.hpp
+++ b/include/boost/core/snprintf.hpp
@@ -0,0 +1,173 @@
+/*
+ *             Copyright Andrey Semashev 2022.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   snprintf.hpp
+ * \author Andrey Semashev
+ * \date   06.12.2022
+ *
+ * \brief  The header provides more portable definition of snprintf and vsnprintf,
+ *         as well as \c wchar_t counterparts.
+ */
+
+#ifndef BOOST_CORE_SNPRINTF_HPP_INCLUDED_
+#define BOOST_CORE_SNPRINTF_HPP_INCLUDED_
+
+#include <stdio.h>
+#include <wchar.h>
+#include <boost/config.hpp>
+
+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if defined(__MINGW32__)
+
+#include <cstddef>
+#include <cstdarg>
+#if !defined(__MINGW64_VERSION_MAJOR)
+#include <climits>
+#endif
+
+// MinGW32 and MinGW-w64 provide their own snprintf implementations that are compliant with the C standard.
+#define BOOST_CORE_DETAIL_MINGW_SNPRINTF
+
+#elif (defined(BOOST_MSSTL_VERSION) && BOOST_MSSTL_VERSION < 140)
+
+#include <cstddef>
+#include <cstdarg>
+#include <climits>
+
+// MSVC snprintfs are not conforming but they are good enough for typical use cases.
+#define BOOST_CORE_DETAIL_MSVC_LEGACY_SNPRINTF
+
+#endif
+
+namespace boost {
+
+namespace core {
+
+#if defined(BOOST_CORE_DETAIL_MINGW_SNPRINTF) || defined(BOOST_CORE_DETAIL_MSVC_LEGACY_SNPRINTF)
+
+#if defined(BOOST_CORE_DETAIL_MINGW_SNPRINTF)
+
+inline int vsnprintf(char* buf, std::size_t size, const char* format, std::va_list args)
+{
+    return __mingw_vsnprintf(buf, size, format, args);
+}
+
+inline int vswprintf(wchar_t* buf, std::size_t size, const wchar_t* format, std::va_list args)
+{
+#if defined(__MINGW64_VERSION_MAJOR)
+    int res = __mingw_vsnwprintf(buf, size, format, args);
+    // __mingw_vsnwprintf returns the number of characters to be printed, but (v)swprintf is expected to return -1 on truncation
+    if (static_cast< unsigned int >(res) >= size)
+        res = -1;
+    return res;
+#else
+    // Legacy MinGW32 does not provide __mingw_vsnwprintf, so use _vsnwprintf from MSVC CRT
+    if (BOOST_UNLIKELY(size == 0u || size > static_cast< std::size_t >(INT_MAX)))
+        return -1;
+
+    int res = _vsnwprintf(buf, size, format, args);
+    // (v)swprintf is expected to return -1 on truncation, so we only need to ensure the output is null-terminated
+    if (static_cast< unsigned int >(res) >= size)
+    {
+        buf[size - 1u] = L'\0';
+        res = -1;
+    }
+
+    return res;
+#endif
+}
+
+#elif defined(BOOST_CORE_DETAIL_MSVC_LEGACY_SNPRINTF)
+
+#if defined(_MSC_VER)
+#pragma warning(push)
+// '_vsnprintf': This function or variable may be unsafe. Consider using _vsnprintf_s instead.
+#pragma warning(disable: 4996)
+#endif
+
+inline int vsnprintf(char* buf, std::size_t size, const char* format, std::va_list args)
+{
+    if (BOOST_UNLIKELY(size == 0u))
+        return 0;
+    if (BOOST_UNLIKELY(size > static_cast< std::size_t >(INT_MAX)))
+        return -1;
+
+    buf[size - 1u] = '\0';
+    int res = _vsnprintf(buf, size, format, args);
+    if (static_cast< unsigned int >(res) >= size)
+    {
+        // _vsnprintf returns -1 if the output was truncated and in case of other errors.
+        // Detect truncation by checking whether the output buffer was written over entirely.
+        if (buf[size - 1u] != '\0')
+        {
+            buf[size - 1u] = '\0';
+            res = static_cast< int >(size);
+        }
+    }
+
+    return res;
+}
+
+inline int vswprintf(wchar_t* buf, std::size_t size, const wchar_t* format, std::va_list args)
+{
+    if (BOOST_UNLIKELY(size == 0u || size > static_cast< std::size_t >(INT_MAX)))
+        return -1;
+
+    int res = _vsnwprintf(buf, size, format, args);
+    // (v)swprintf is expected to return -1 on truncation, so we only need to ensure the output is null-terminated
+    if (static_cast< unsigned int >(res) >= size)
+    {
+        buf[size - 1u] = L'\0';
+        res = -1;
+    }
+
+    return res;
+}
+
+#if defined(_MSC_VER)
+#pragma warning(pop)
+#endif
+
+#endif
+
+inline int snprintf(char* buf, std::size_t size, const char* format, ...)
+{
+    std::va_list args;
+    va_start(args, format);
+    int res = vsnprintf(buf, size, format, args);
+    va_end(args);
+    return res;
+}
+
+inline int swprintf(wchar_t* buf, std::size_t size, const wchar_t* format, ...)
+{
+    std::va_list args;
+    va_start(args, format);
+    int res = vswprintf(buf, size, format, args);
+    va_end(args);
+    return res;
+}
+
+#else // defined(BOOST_CORE_DETAIL_MINGW_SNPRINTF) || defined(BOOST_CORE_DETAIL_MSVC_LEGACY_SNPRINTF)
+
+// Standard-conforming compilers already have the correct snprintfs
+using ::snprintf;
+using ::vsnprintf;
+
+using ::swprintf;
+using ::vswprintf;
+
+#endif // defined(BOOST_CORE_DETAIL_MINGW_SNPRINTF) || defined(BOOST_CORE_DETAIL_MSVC_LEGACY_SNPRINTF)
+
+} // namespace core
+
+} // namespace boost
+
+#endif // BOOST_CORE_SNPRINTF_HPP_INCLUDED_
--- a/include/boost/core/swap.hpp
+++ b/include/boost/core/swap.hpp
@@ -13,10 +13,10 @@
 // - swap_impl is put outside the boost namespace, to avoid infinite
 // recursion (causing stack overflow) when swapping objects of a primitive
 // type.
-// - swap_impl has a using-directive, rather than a using-declaration,
-// because some compilers (including MSVC 7.1, Borland 5.9.3, and
-// Intel 8.1) don't do argument-dependent lookup when it has a
-// using-declaration instead.
+// - std::swap is imported with a using-directive, rather than
+// a using-declaration, because some compilers (including MSVC 7.1,
+// Borland 5.9.3, and Intel 8.1) don't do argument-dependent lookup
+// when it has a using-declaration instead.
 // - boost::swap has two template arguments, instead of one, to
 // avoid ambiguity when swapping objects of a Boost type that does
 // not have its own boost::swap overload.
@@ -30,6 +30,17 @@
 #endif
 #include <cstddef> // for std::size_t

+#ifdef BOOST_HAS_PRAGMA_ONCE
+#pragma once
+#endif
+
+#if defined(BOOST_GCC) && (BOOST_GCC < 40700)
+// gcc 4.6 ICEs on noexcept specifications below
+#define BOOST_CORE_SWAP_NOEXCEPT_IF(x)
+#else
+#define BOOST_CORE_SWAP_NOEXCEPT_IF(x) BOOST_NOEXCEPT_IF(x)
+#endif
+
 namespace boost_swap_impl
 {
  // we can't use type_traits here
@@ -37,17 +48,22 @@ namespace boost_swap_impl
  template<class T> struct is_const { enum _vt { value = 0 }; };
  template<class T> struct is_const<T const> { enum _vt { value = 1 }; };

+  // Use std::swap if argument dependent lookup fails.
+  // We need to have this at namespace scope to be able to use unqualified swap() call
+  // in noexcept specification.
+  using namespace std;
+
  template<class T>
  BOOST_GPU_ENABLED
-  void swap_impl(T& left, T& right)
+  void swap_impl(T& left, T& right) BOOST_CORE_SWAP_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(swap(left, right)))
  {
-    using namespace std;//use std::swap if argument dependent lookup fails
-    swap(left,right);
+    swap(left, right);
  }

  template<class T, std::size_t N>
  BOOST_GPU_ENABLED
  void swap_impl(T (& left)[N], T (& right)[N])
+    BOOST_CORE_SWAP_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(::boost_swap_impl::swap_impl(left[0], right[0])))
  {
    for (std::size_t i = 0; i < N; ++i)
    {
@@ -62,9 +78,12 @@ namespace boost
  BOOST_GPU_ENABLED
  typename enable_if_c< !boost_swap_impl::is_const<T1>::value && !boost_swap_impl::is_const<T2>::value >::type
  swap(T1& left, T2& right)
+    BOOST_CORE_SWAP_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(::boost_swap_impl::swap_impl(left, right)))
  {
    ::boost_swap_impl::swap_impl(left, right);
  }
 }

-#endif
+#undef BOOST_CORE_SWAP_NOEXCEPT_IF
+
+#endif // BOOST_CORE_SWAP_HPP
--- a/include/boost/core/type_name.hpp
+++ b/include/boost/core/type_name.hpp
@@ -14,7 +14,6 @@
 // https://www.boost.org/LICENSE_1_0.txt

 #include <boost/core/demangle.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/config.hpp>
 #include <string>
 #include <functional>
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -6,7 +6,7 @@ include(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)

 if(HAVE_BOOST_TEST)

-boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::core Boost::static_assert)
+boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::core Boost::static_assert Boost::type_traits)

 set(BOOST_TEST_LINK_LIBRARIES Boost::core Boost::type_traits)

--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -14,8 +14,6 @@ project : requirements
  <warnings>extra
  <toolset>msvc:<warnings-as-errors>on
  <toolset>clang:<warnings-as-errors>on
-  # https://github.com/boostorg/type_traits/issues/173
-  <toolset>clang-15:<cxxflags>-Wno-deprecated-builtins
  <toolset>gcc:<warnings-as-errors>on
  <toolset>gcc-4.4:<cxxflags>-Wno-sign-compare ;

@@ -150,6 +148,7 @@ run-fail lightweight_test_fail12.cpp ;
 run-fail lightweight_test_fail13.cpp ;
 run-fail lightweight_test_fail14.cpp ;
 run-fail lightweight_test_fail15.cpp ;
+run-fail lightweight_test_fail16.cpp : ;
 run-fail lightweight_test_lt_fail.cpp ;
 run-fail lightweight_test_le_fail.cpp ;
 run-fail lightweight_test_gt_fail.cpp ;
@@ -303,6 +302,8 @@ compile-fail bit_width_fail.cpp

 run type_name_test.cpp ;

+run snprintf_test.cpp ;
+
 run sv_types_test.cpp ;
 run sv_construct_test.cpp ;
 run sv_iteration_test.cpp ;
@@ -351,5 +352,9 @@ run-fail verbose_terminate_handler_fail.cpp : : : <exception-handling>off : verb
 run-fail verbose_terminate_handler_fail.cpp : : : <rtti>off : verbose_terminate_handler_fail_nr ;
 run-fail verbose_terminate_handler_fail.cpp : : : <exception-handling>off <rtti>off : verbose_terminate_handler_fail_nxr ;

+run launder_test.cpp ;
+
+run alignof_test.cpp ;
+
 use-project /boost/core/swap : ./swap ;
 build-project ./swap ;
--- a/test/alignof_test.cpp
+++ b/test/alignof_test.cpp
@@ -0,0 +1,98 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/alignof.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/type_traits.hpp>
+#include <boost/config.hpp>
+#include <cstddef>
+
+template<class T> struct struct_of
+{
+    T t;
+};
+
+template<class T> union union_of
+{
+    T t;
+};
+
+template<class T> void test2()
+{
+    BOOST_TEST_EQ( BOOST_CORE_ALIGNOF(T), boost::alignment_of<T>::value );
+
+#if !defined(BOOST_NO_CXX11_ALIGNOF)
+
+    BOOST_TEST_EQ( BOOST_CORE_ALIGNOF(T), alignof(T) );
+
+#endif
+}
+
+template<class T> void test()
+{
+    test2<T>();
+    test2<T[2]>();
+    test2< struct_of<T> >();
+    test2< union_of<T> >();
+}
+
+struct X
+{
+};
+
+int main()
+{
+    test<char>();
+    test<short>();
+    test<int>();
+    test<long>();
+
+#if !defined(BOOST_NO_LONG_LONG)
+# if !( defined(__GNUC__) && defined(__i386__) )
+
+    // g++ -m32 has alignof(long long) = 8, but boost::alignment_of<long long>::value = 4
+    test<boost::long_long_type>();
+
+# endif
+#endif
+
+#if defined(BOOST_HAS_INT128)
+
+    test<boost::int128_type>();
+
+#endif
+
+    test<float>();
+
+#if !( defined(__GNUC__) && defined(__i386__) )
+
+    // g++ -m32 has alignof(double) = 8, but boost::alignment_of<double>::value = 4
+    test<double>();
+
+#endif
+
+    test<long double>();
+
+#if defined(BOOST_HAS_FLOAT128)
+
+    test<__float128>();
+
+#endif
+
+    test<void*>();
+    test<void(*)()>();
+
+#if !defined(_MSC_VER)
+
+    // under MSVC, alignof is 8, boost::alignment_of is 4
+    // under clang-cl, alignof is 4, boost::alignment_of is 8 (!)
+
+    test<int X::*>();
+
+#endif
+
+    test<void (X::*)()>();
+
+    return boost::report_errors();
+}
--- a/test/alloc_construct_cxx11_test.cpp
+++ b/test/alloc_construct_cxx11_test.cpp
@@ -72,6 +72,7 @@ int main()
    BOOST_TEST_EQ(p->value(), 2);
    boost::alloc_destroy(a, p);
    BOOST_TEST_EQ(type::count, 0);
+    a.deallocate(p, 1);
    return boost::report_errors();
 }
 #else
--- a/test/allocator_const_pointer_test.cpp
+++ b/test/allocator_const_pointer_test.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>

 template<class T>
 struct A1 {
@@ -22,9 +22,9 @@ struct A2 {

 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
        boost::allocator_const_pointer<A1<char> >::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int*,
        boost::allocator_const_pointer<A2<int> >::type>));
    return boost::report_errors();
 }
--- a/test/allocator_const_void_pointer_test.cpp
+++ b/test/allocator_const_void_pointer_test.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>

 template<class T>
 struct A1 {
@@ -27,9 +27,9 @@ struct A2 {

 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
        boost::allocator_const_void_pointer<A1<char> >::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const void*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const void*,
        boost::allocator_const_void_pointer<A2<int> >::type>));
    return boost::report_errors();
 }
--- a/test/allocator_difference_type_test.cpp
+++ b/test/allocator_difference_type_test.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>

 template<class T>
 struct A1 {
@@ -22,9 +22,9 @@ struct A2 {

 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<short,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<short,
        boost::allocator_difference_type<A1<char> >::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
        boost::allocator_difference_type<A2<int> >::type>));
    return boost::report_errors();
 }
--- a/test/allocator_is_always_equal_test.cpp
+++ b/test/allocator_is_always_equal_test.cpp
@@ -6,7 +6,6 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>

 template<class T>
--- a/test/allocator_pocca_test.cpp
+++ b/test/allocator_pocca_test.cpp
@@ -6,7 +6,6 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>

 template<class T>
--- a/test/allocator_pocma_test.cpp
+++ b/test/allocator_pocma_test.cpp
@@ -6,7 +6,6 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>

 template<class T>
--- a/test/allocator_pocs_test.cpp
+++ b/test/allocator_pocs_test.cpp
@@ -6,7 +6,6 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>

 template<class T>
--- a/test/allocator_pointer_test.cpp
+++ b/test/allocator_pointer_test.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>

 template<class T>
 struct A1 {
@@ -22,9 +22,9 @@ struct A2 {

 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
        boost::allocator_pointer<A1<char> >::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
        boost::allocator_pointer<A2<int> >::type>));
    return boost::report_errors();
 }
--- a/test/allocator_rebind_test.cpp
+++ b/test/allocator_rebind_test.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>

 template<class T>
 struct A1 {
@@ -25,9 +25,9 @@ struct A2 {

 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<A1<int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<A1<int>,
        boost::allocator_rebind<A1<char>, bool>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<A2<int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<A2<int>,
        boost::allocator_rebind<A2<char>, int>::type>));
    return boost::report_errors();
 }
--- a/test/allocator_size_type_test.cpp
+++ b/test/allocator_size_type_test.cpp
@@ -6,8 +6,11 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/type_traits/is_same.hpp>
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+#include <boost/type_traits/make_unsigned.hpp>
+#endif

 template<class T>
 struct A1 {
@@ -24,11 +27,11 @@ struct A2 {

 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+    BOOST_TEST_TRAIT_TRUE((boost::is_same<int,
        boost::allocator_size_type<A1<char> >::type>));
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<
-        std::make_unsigned<std::ptrdiff_t>::type,
+    BOOST_TEST_TRAIT_TRUE((boost::is_same<
+        boost::make_unsigned<std::ptrdiff_t>::type,
        boost::allocator_size_type<A2<int> >::type>));
 #endif
    return boost::report_errors();
--- a/test/allocator_value_type_test.cpp
+++ b/test/allocator_value_type_test.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>

 template<class T>
 struct A {
@@ -16,7 +16,7 @@ struct A {

 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
        boost::allocator_value_type<A<int> >::type>));
    return boost::report_errors();
 }
--- a/test/allocator_void_pointer_test.cpp
+++ b/test/allocator_void_pointer_test.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/allocator_access.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>

 template<class T>
 struct A1 {
@@ -27,9 +27,9 @@ struct A2 {

 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
        boost::allocator_void_pointer<A1<char> >::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void*,
        boost::allocator_void_pointer<A2<int> >::type>));
    return boost::report_errors();
 }
--- a/test/detail_iterator_test.cpp
+++ b/test/detail_iterator_test.cpp
@@ -10,8 +10,8 @@

 #define BOOST_ALLOW_DEPRECATED_HEADERS
 #include <boost/detail/iterator.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/type_traits/is_same.hpp>
 #include <cstddef>
 #include <list>

@@ -62,7 +62,7 @@ struct iterator

 int main()
 {
-    using boost::core::is_same;
+    using boost::is_same;

 /*
    template<class Iterator> struct iterator_traits {
--- a/test/eif_lazy_test.cpp
+++ b/test/eif_lazy_test.cpp
@@ -12,7 +12,7 @@

 // Testing all variations of lazy_enable_if.

-#include <boost/utility/enable_if.hpp>
+#include <boost/core/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/core/lightweight_test.hpp>

@@ -26,7 +26,7 @@ using boost::lazy_disable_if_c;
 template <class T>
 struct is_int_or_double {
  BOOST_STATIC_CONSTANT(bool, 
-    value = (boost::is_same<T, int>::value || 
+    value = (boost::is_same<T, int>::value ||
             boost::is_same<T, double>::value));
 };

@@ -84,14 +84,14 @@ int main()
  BOOST_TEST(foo(1));
  BOOST_TEST(foo(1.0));

-  BOOST_TEST(!foo("1"));  
-  BOOST_TEST(!foo(static_cast<void*>(0)));  
+  BOOST_TEST(!foo("1"));
+  BOOST_TEST(!foo(static_cast<void*>(0)));

  BOOST_TEST(foo2(1));
  BOOST_TEST(foo2(1.0));

-  BOOST_TEST(!foo2("1"));  
-  BOOST_TEST(!foo2(static_cast<void*>(0)));  
+  BOOST_TEST(!foo2("1"));
+  BOOST_TEST(!foo2(static_cast<void*>(0)));

  return boost::report_errors();
 }
--- a/test/is_same_test.cpp
+++ b/test/is_same_test.cpp
@@ -1,5 +1,5 @@
 //
-// Test for core::is_same<T1,T2>
+// Test for core::detail::is_same<T1,T2>
 //
 // Copyright 2014 Peter Dimov
 //
@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //

-#include <boost/core/is_same.hpp>
+#include <boost/core/detail/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>

 struct X
@@ -21,18 +21,18 @@ struct Y

 int main()
 {
-    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<X, X> ));
-    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<Y, Y> ));
-    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<void, void> ));
-    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<int, int> ));
-    BOOST_TEST_TRAIT_TRUE(( boost::core::is_same<void const volatile, void const volatile> ));
+    BOOST_TEST_TRAIT_TRUE(( boost::core::detail::is_same<X, X> ));
+    BOOST_TEST_TRAIT_TRUE(( boost::core::detail::is_same<Y, Y> ));
+    BOOST_TEST_TRAIT_TRUE(( boost::core::detail::is_same<void, void> ));
+    BOOST_TEST_TRAIT_TRUE(( boost::core::detail::is_same<int, int> ));
+    BOOST_TEST_TRAIT_TRUE(( boost::core::detail::is_same<void const volatile, void const volatile> ));

-    BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<X, Y> ));
-    BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<X, X const> ));
-    BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<X, void> ));
-    BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<X, int> ));
-    BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<int, void> ));
-    BOOST_TEST_TRAIT_FALSE(( boost::core::is_same<void, void const volatile> ));
+    BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<X, Y> ));
+    BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<X, X const> ));
+    BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<X, void> ));
+    BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<X, int> ));
+    BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<int, void> ));
+    BOOST_TEST_TRAIT_FALSE(( boost::core::detail::is_same<void, void const volatile> ));

    return boost::report_errors();
 }
--- a/test/iterator_test.cpp
+++ b/test/iterator_test.cpp
@@ -18,8 +18,8 @@
 #if BOOST_CXX_VERSION < 201703

 #include <boost/iterator.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/type_traits/is_same.hpp>

 /*

@@ -60,7 +60,7 @@ struct R

 int main()
 {
-    using boost::core::is_same;
+    using boost::is_same;

    BOOST_TEST_TRAIT_TRUE((is_same<boost::iterator<C,T,D,P,R>::iterator_category,C>));
    BOOST_TEST_TRAIT_TRUE((is_same<boost::iterator<C,T,D,P,R>::value_type,T>));
--- a/test/launder_test.cpp
+++ b/test/launder_test.cpp
@@ -0,0 +1,34 @@
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/launder.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <new>
+
+struct X
+{
+    int v_;
+
+    explicit X( int v = 0 ): v_( v ) {}
+};
+
+int main()
+{
+    X x;
+
+    typedef X const CX;
+
+    ::new( &x ) CX( 1 );
+    X const* px1 = &x;
+
+    BOOST_TEST_EQ( px1->v_, 1 );
+
+    ::new( &x ) CX( 2 );
+    X const* px2 = boost::core::launder( px1 );
+
+    BOOST_TEST_EQ( px1, px2 );
+    BOOST_TEST_EQ( px2->v_, 2 );
+
+    return boost::report_errors();
+}
--- a/test/lightweight_test_fail16.cpp
+++ b/test/lightweight_test_fail16.cpp
@@ -0,0 +1,12 @@
+// Copyright 2022 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/core/lightweight_test.hpp>
+
+// Should fail, because boost::report_errors() hasn't been called
+
+int main()
+{
+    boost::core::lwt_init();
+}
--- a/test/pointer_traits_difference_type_test.cpp
+++ b/test/pointer_traits_difference_type_test.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/pointer_traits.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>

 template<class T>
 struct P { };
@@ -19,23 +19,23 @@ struct E {

 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
        boost::pointer_traits<int*>::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
        boost::pointer_traits<P<int> >::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<long,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<long,
        boost::pointer_traits<E<int> >::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
        boost::pointer_traits<void*>::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
        boost::pointer_traits<P<void> >::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<long,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<long,
        boost::pointer_traits<E<void> >::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
        boost::pointer_traits<const int*>::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<std::ptrdiff_t,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<std::ptrdiff_t,
        boost::pointer_traits<P<const int> >::difference_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<long,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<long,
        boost::pointer_traits<E<const int> >::difference_type>));
    return boost::report_errors();
 }
--- a/test/pointer_traits_element_type_test.cpp
+++ b/test/pointer_traits_element_type_test.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/pointer_traits.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>

 template<class T>
 struct P1 { };
@@ -45,39 +45,39 @@ struct E {

 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
        boost::pointer_traits<int*>::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
        boost::pointer_traits<P1<int> >::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
        boost::pointer_traits<P2<int, char> >::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
        boost::pointer_traits<P3<int, char, char> >::element_type>));
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int,
        boost::pointer_traits<P<int, char, char, char> >::element_type>));
 #endif
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
        boost::pointer_traits<E1<int> >::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
        boost::pointer_traits<E2<int, int> >::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
        boost::pointer_traits<E3<int, int, int> >::element_type>));
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
        boost::pointer_traits<E<int, int, int, int> >::element_type>));
 #endif
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void,
        boost::pointer_traits<void*>::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void,
        boost::pointer_traits<P1<void> >::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
        boost::pointer_traits<E1<void> >::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int,
        boost::pointer_traits<const int*>::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int,
        boost::pointer_traits<P1<const int> >::element_type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<bool,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<bool,
        boost::pointer_traits<E1<const int> >::element_type>));
    return boost::report_errors();
 }
--- a/test/pointer_traits_pointer_test.cpp
+++ b/test/pointer_traits_pointer_test.cpp
@@ -6,25 +6,25 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/pointer_traits.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>

 template<class T>
 struct P { };

 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
        boost::pointer_traits<int*>::pointer>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P<int>,
        boost::pointer_traits<P<int> >::pointer>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void*,
        boost::pointer_traits<void*>::pointer>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<void>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P<void>,
        boost::pointer_traits<P<void> >::pointer>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int*,
        boost::pointer_traits<const int*>::pointer>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<const int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P<const int>,
        boost::pointer_traits<P<const int> >::pointer>));
    return boost::report_errors();
 }
--- a/test/pointer_traits_rebind_test.cpp
+++ b/test/pointer_traits_rebind_test.cpp
@@ -6,8 +6,8 @@ Distributed under the Boost Software License, Version 1.0.
 (http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/pointer_traits.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
+#include <boost/core/detail/is_same.hpp>

 template<class T>
 struct P1 { };
@@ -55,94 +55,94 @@ struct R { };

 int main()
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<char*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<char*,
        boost::pointer_traits<R*>::rebind_to<char>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<char>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<char>,
        boost::pointer_traits<P1<R> >::rebind_to<char>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P2<char, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P2<char, R>,
        boost::pointer_traits<P2<R, R> >::rebind_to<char>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P3<char, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P3<char, R, R>,
        boost::pointer_traits<P3<R, R, R> >::rebind_to<char>::type>));
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<char, R, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P<char, R, R, R>,
        boost::pointer_traits<P<R, R, R, R> >::rebind_to<char>::type>));
 #endif
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void*,
        boost::pointer_traits<R*>::rebind_to<void>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<void>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<void>,
        boost::pointer_traits<P1<R> >::rebind_to<void>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<R*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<R*,
        boost::pointer_traits<void*>::rebind_to<R>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<R>,
        boost::pointer_traits<P1<void> >::rebind_to<R>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int*,
        boost::pointer_traits<R*>::rebind_to<const int>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<const int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<const int>,
        boost::pointer_traits<P1<R> >::rebind_to<const int>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
        boost::pointer_traits<const R*>::rebind_to<int>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<int>,
        boost::pointer_traits<P1<const R> >::rebind_to<int>::type>));
 #if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<char*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<char*,
        boost::pointer_traits<R*>::rebind<char> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<char>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<char>,
        boost::pointer_traits<P1<R> >::rebind<char> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P2<char, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P2<char, R>,
        boost::pointer_traits<P2<R, R> >::rebind<char> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P3<char, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P3<char, R, R>,
        boost::pointer_traits<P3<R, R, R> >::rebind<char> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<void*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<void*,
        boost::pointer_traits<R*>::rebind<void> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<void>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<void>,
        boost::pointer_traits<P1<R> >::rebind<void> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<R*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<R*,
        boost::pointer_traits<void*>::rebind<R> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<R>,
        boost::pointer_traits<P1<void> >::rebind<R> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<const int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<const int*,
        boost::pointer_traits<R*>::rebind<const int> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<const int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<const int>,
        boost::pointer_traits<P1<R> >::rebind<const int> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<int*,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<int*,
        boost::pointer_traits<const R*>::rebind<int> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P1<int>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P1<int>,
        boost::pointer_traits<P1<const R> >::rebind<int> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
        boost::pointer_traits<E1<R> >::rebind_to<char>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E2<bool, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E2<bool, R>,
        boost::pointer_traits<E2<R, R> >::rebind_to<char>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E3<bool, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E3<bool, R, R>,
        boost::pointer_traits<E3<R, R, R> >::rebind_to<char>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
        boost::pointer_traits<E1<R> >::rebind<char> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E2<bool, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E2<bool, R>,
        boost::pointer_traits<E2<R, R> >::rebind<char> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E3<bool, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E3<bool, R, R>,
        boost::pointer_traits<E3<R, R, R> >::rebind<char> >));
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<P<char, R, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<P<char, R, R, R>,
        boost::pointer_traits<P<R, R, R, R> >::rebind<char> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E<bool, R, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E<bool, R, R, R>,
        boost::pointer_traits<E<R, R, R, R> >::rebind_to<char>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E<bool, R, R, R>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E<bool, R, R, R>,
        boost::pointer_traits<E<R, R, R, R> >::rebind<char> >));
 #endif
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
        boost::pointer_traits<E1<R> >::rebind_to<void>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
        boost::pointer_traits<E1<void> >::rebind_to<R>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
        boost::pointer_traits<E1<R> >::rebind_to<const int>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
        boost::pointer_traits<E1<const R> >::rebind_to<int>::type>));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
        boost::pointer_traits<E1<R> >::rebind<void> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
        boost::pointer_traits<E1<void> >::rebind<R> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
        boost::pointer_traits<E1<R> >::rebind<const int> >));
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same<E1<bool>,
+    BOOST_TEST_TRAIT_TRUE((boost::core::detail::is_same<E1<bool>,
        boost::pointer_traits<E1<const R> >::rebind<int> >));
 #endif
    return boost::report_errors();
--- a/test/quick.cpp
+++ b/test/quick.cpp
@@ -16,13 +16,12 @@
 #include <boost/core/explicit_operator_bool.hpp>
 #include <boost/get_pointer.hpp>
 #include <boost/core/ignore_unused.hpp>
-#include <boost/core/is_same.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/noncopyable.hpp>
 #include <boost/core/null_deleter.hpp>
 #include <boost/core/fclose_deleter.hpp>
 #include <boost/core/pointer_traits.hpp>
-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/core/scoped_enum.hpp>
 #include <boost/core/typeinfo.hpp>
 #include <boost/core/underlying_type.hpp>
--- a/test/ref_conversion_test.cpp
+++ b/test/ref_conversion_test.cpp
@@ -6,7 +6,7 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt

-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/core/lightweight_test.hpp>

 struct X
--- a/test/ref_ct_test.cpp
+++ b/test/ref_ct_test.cpp
@@ -3,13 +3,13 @@
 // 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

-// compile-time test for "boost/ref.hpp" header content
+// compile-time test for "boost/core/ref.hpp" header content
 // see 'ref_test.cpp' for run-time part

-#include <boost/ref.hpp>
-#include <boost/core/is_same.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/config/workaround.hpp>
+#include <boost/type_traits/is_same.hpp>

 namespace {

@@ -17,8 +17,8 @@ template< typename T, typename U >
 void ref_test(boost::reference_wrapper<U>)
 {
    typedef typename boost::reference_wrapper<U>::type type;
-    BOOST_STATIC_ASSERT((boost::core::is_same<U,type>::value));
-    BOOST_STATIC_ASSERT((boost::core::is_same<T,type>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<U,type>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<T,type>::value));
 }

 template< typename T >
@@ -42,14 +42,14 @@ void is_reference_wrapper_test(T)
 template< typename R, typename Ref >
 void cxx_reference_test(Ref)
 {
-    BOOST_STATIC_ASSERT((boost::core::is_same<R,Ref>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<R,Ref>::value));
 }

 template< typename R, typename Ref >
 void unwrap_reference_test(Ref)
 {
    typedef typename boost::unwrap_reference<Ref>::type type;
-    BOOST_STATIC_ASSERT((boost::core::is_same<R,type>::value));
+    BOOST_STATIC_ASSERT((boost::is_same<R,type>::value));
 }

 } // namespace
--- a/test/ref_cv_test.cpp
+++ b/test/ref_cv_test.cpp
@@ -6,7 +6,7 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt

-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/core/lightweight_test.hpp>

 #define BOOST_TEST_REF( x ) BOOST_TEST( &boost::ref( x ).get() == &x )
--- a/test/ref_fn_test.cpp
+++ b/test/ref_fn_test.cpp
@@ -15,7 +15,7 @@
 //  See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt

-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/core/lightweight_test.hpp>


--- a/test/ref_implicit_fail.cpp
+++ b/test/ref_implicit_fail.cpp
@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //

-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>

 void f( boost::reference_wrapper< int > )
 {
--- a/test/ref_implicit_fail2.cpp
+++ b/test/ref_implicit_fail2.cpp
@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //

-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>

 void f( boost::reference_wrapper< int const > )
 {
--- a/test/ref_implicit_fail3.cpp
+++ b/test/ref_implicit_fail3.cpp
@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //

-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>

 struct X
 {
--- a/test/ref_implicit_fail4.cpp
+++ b/test/ref_implicit_fail4.cpp
@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //

-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>

 void f( boost::reference_wrapper< int const > )
 {
--- a/test/ref_ref_test.cpp
+++ b/test/ref_ref_test.cpp
@@ -11,7 +11,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //

-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/core/lightweight_test.hpp>

 template<class T> void test( T const & t )
--- a/test/ref_rv_fail1.cpp
+++ b/test/ref_rv_fail1.cpp
@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //

-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>

 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

--- a/test/ref_rv_fail2.cpp
+++ b/test/ref_rv_fail2.cpp
@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //

-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>

 int main()
 {
--- a/test/ref_rv_fail3.cpp
+++ b/test/ref_rv_fail3.cpp
@@ -8,7 +8,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //

-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>

 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

--- a/test/ref_rv_fail4.cpp
+++ b/test/ref_rv_fail4.cpp
@@ -9,7 +9,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //

-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>

 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

--- a/test/ref_rv_fail5.cpp
+++ b/test/ref_rv_fail5.cpp
@@ -9,7 +9,7 @@
 // http://www.boost.org/LICENSE_1_0.txt
 //

-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>

 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)

--- a/test/ref_test.cpp
+++ b/test/ref_test.cpp
@@ -3,10 +3,10 @@
 // 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)

-// run-time test for "boost/ref.hpp" header content
+// run-time test for "boost/core/ref.hpp" header content
 // see 'ref_ct_test.cpp' for compile-time part

-#include <boost/ref.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/core/lightweight_test.hpp>

 namespace {
--- a/test/snprintf_test.cpp
+++ b/test/snprintf_test.cpp
@@ -0,0 +1,86 @@
+/*
+ *             Copyright Andrey Semashev 2022.
+ * Distributed under the Boost Software License, Version 1.0.
+ *    (See accompanying file LICENSE_1_0.txt or copy at
+ *          http://www.boost.org/LICENSE_1_0.txt)
+ */
+/*!
+ * \file   snprintf_test.cpp
+ * \author Andrey Semashev
+ * \date   06.12.2022
+ *
+ * This file contains tests for \c boost::core::snprintf.
+ */
+
+#include <boost/core/snprintf.hpp>
+#include <cstddef>
+#include <cstring>
+#include <boost/core/lightweight_test.hpp>
+
+void test_snprintf()
+{
+    char buf[11];
+    std::memset(buf, 0xFF, sizeof(buf));
+
+    std::size_t buf_size = sizeof(buf) - 1u;
+
+    int res = boost::core::snprintf(buf, buf_size, "%s", "0123");
+    BOOST_TEST_EQ(res, 4);
+    int cmp_res = std::memcmp(buf, "0123", sizeof("0123"));
+    BOOST_TEST_EQ(cmp_res, 0);
+
+    std::memset(buf, 0xFF, sizeof(buf));
+
+    // Suppress compiler checks for buffer overflow
+    const char* volatile str = "0123456789";
+
+    res = boost::core::snprintf(buf, buf_size, "%s", str);
+    BOOST_TEST_GE(res, 10);
+    cmp_res = std::memcmp(buf, "012345678", sizeof("012345678"));
+    BOOST_TEST_EQ(cmp_res, 0);
+    BOOST_TEST_EQ(buf[10], static_cast< char >(~static_cast< char >(0)));
+
+    std::memset(buf, 0xFF, sizeof(buf));
+
+    res = boost::core::snprintf(buf, 0, "%s", str);
+    BOOST_TEST_GE(res, 0);
+    BOOST_TEST_EQ(buf[0], static_cast< char >(~static_cast< char >(0)));
+}
+
+void test_swprintf()
+{
+    wchar_t buf[11];
+    std::memset(buf, 0xFF, sizeof(buf));
+
+    std::size_t buf_size = sizeof(buf) / sizeof(*buf) - 1u;
+
+    int res = boost::core::swprintf(buf, buf_size, L"%ls", L"0123");
+    BOOST_TEST_EQ(res, 4);
+    int cmp_res = std::memcmp(buf, L"0123", sizeof(L"0123"));
+    BOOST_TEST_EQ(cmp_res, 0);
+
+    std::memset(buf, 0xFF, sizeof(buf));
+
+    // Suppress compiler checks for buffer overflow
+    const wchar_t* volatile str = L"0123456789";
+
+    res = boost::core::swprintf(buf, buf_size, L"%ls", str);
+    BOOST_TEST_LT(res, 0);
+    // swprintf may or may not write to the buffer in case of overflow.
+    // E.g. glibc 2.35 doesn't and libc on MacOS 11 does.
+    BOOST_TEST_EQ(buf[10], static_cast< wchar_t >(~static_cast< wchar_t >(0)));
+
+    std::memset(buf, 0xFF, sizeof(buf));
+
+    res = boost::core::swprintf(buf, 0, L"%ls", str);
+    BOOST_TEST_LT(res, 0);
+    BOOST_TEST_EQ(buf[0], static_cast< wchar_t >(~static_cast< wchar_t >(0)));
+}
+
+int main()
+{
+    test_snprintf();
+    test_swprintf();
+
+    return boost::report_errors();
+}
--- a/test/sv_types_test.cpp
+++ b/test/sv_types_test.cpp
@@ -5,7 +5,6 @@
 #include <boost/core/detail/string_view.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
-#include <boost/core/is_same.hpp>
 #include <iterator>

 struct Ch
--- a/test/swap/Jamfile.v2
+++ b/test/swap/Jamfile.v2
@@ -13,6 +13,7 @@ compile swap_lib_header_1.cpp ;
 compile swap_lib_header_2.cpp ;
 compile swap_mixed_headers_1.cpp ;
 compile swap_mixed_headers_2.cpp ;
+compile swap_noexcept.cpp ;

 compile-fail swap_const_wrapper_fail.cpp ;

--- a/test/swap/swap_array_of_class.cpp
+++ b/test/swap/swap_array_of_class.cpp
@@ -46,13 +46,13 @@ int main()
  const std::size_t array_size = 2;
  const swap_test_class initial_array1[array_size] = { swap_test_class(1), swap_test_class(2) };
  const swap_test_class initial_array2[array_size] = { swap_test_class(3), swap_test_class(4) };
-  
+
  swap_test_class array1[array_size];
  swap_test_class array2[array_size];

  std::copy(initial_array1, initial_array1 + array_size, array1);
  std::copy(initial_array2, initial_array2 + array_size, array2);
-  
+
  swap_test_class::reset();
  boost::swap(array1, array2);

--- a/test/swap/swap_array_of_int.cpp
+++ b/test/swap/swap_array_of_int.cpp
@@ -20,13 +20,13 @@ int main()
  const std::size_t array_size = 3;
  const int initial_array1[array_size] = { 1, 2, 3 };
  const int initial_array2[array_size] = { 4, 5, 6 };
-  
+
  int array1[array_size];
  int array2[array_size];

  std::copy(initial_array1, initial_array1 + array_size, array1);
  std::copy(initial_array2, initial_array2 + array_size, array2);
-  
+
  boost::swap(array1, array2);

  BOOST_CHECK(std::equal(array1, array1 + array_size, initial_array2));
--- a/test/swap/swap_array_of_template.cpp
+++ b/test/swap/swap_array_of_template.cpp
@@ -52,13 +52,13 @@ int main()
  const std::size_t array_size = 2;
  const swap_test_template<int> initial_array1[array_size] = { { swap_test_class(1) }, { swap_test_class(2) } };
  const swap_test_template<int> initial_array2[array_size] = { { swap_test_class(3) }, { swap_test_class(4) } };
-  
+
  swap_test_template<int> array1[array_size];
  swap_test_template<int> array2[array_size];

  std::copy(initial_array1, initial_array1 + array_size, array1);
  std::copy(initial_array2, initial_array2 + array_size, array2);
-  
+
  swap_test_class::reset();
  boost::swap(array1, array2);

--- a/test/swap/swap_const_wrapper_fail.cpp
+++ b/test/swap/swap_const_wrapper_fail.cpp
@@ -6,7 +6,7 @@

 namespace boost
 {
-  
+
 template<class T> struct Wrapper
 {
    T value;
@@ -16,9 +16,9 @@ template<class T> inline void swap( Wrapper<T> & w, Wrapper<T> & v )
 {
    boost::swap( w, v );
 }
-  
+
 } // namespace boost
- 
+
 int main()
 {
    boost::Wrapper<int> const w = { 2 };
--- a/test/swap/swap_noexcept.cpp
+++ b/test/swap/swap_noexcept.cpp
@@ -0,0 +1,42 @@
+// Copyright (c) 2023 Andrey Semashev
+//
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+// Tests that boost::swap propagates noexcept specification correctly
+
+#include <boost/core/swap.hpp>
+#include <boost/config.hpp>
+
+#if !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_STATIC_ASSERT) && \
+    !(defined(BOOST_GCC) && (BOOST_GCC < 40700))
+
+namespace test_ns {
+
+struct class_with_noexcept_swap
+{
+    static class_with_noexcept_swap& instance() noexcept;
+
+    friend void swap(class_with_noexcept_swap&, class_with_noexcept_swap&) noexcept
+    {
+    }
+};
+
+struct class_with_except_swap
+{
+    static class_with_except_swap& instance() noexcept;
+
+    friend void swap(class_with_except_swap&, class_with_except_swap&)
+    {
+    }
+};
+
+} // namespace test_ns
+
+static_assert(noexcept(boost::swap(test_ns::class_with_noexcept_swap::instance(), test_ns::class_with_noexcept_swap::instance())),
+    "boost::swap for class_with_noexcept_swap should have noexcept specification");
+static_assert(!noexcept(boost::swap(test_ns::class_with_except_swap::instance(), test_ns::class_with_except_swap::instance())),
+    "boost::swap for class_with_except_swap should not have noexcept specification");
+
+#endif // !defined(BOOST_NO_CXX11_NOEXCEPT) && !defined(BOOST_NO_CXX11_STATIC_ASSERT) ...
--- a/test/swap/swap_specialized_in_boost.cpp
+++ b/test/swap/swap_specialized_in_boost.cpp
@@ -31,7 +31,7 @@ int main()

  boost::swap_test_class object1 = initial_value1;
  boost::swap_test_class object2 = initial_value2;
-  
+
  boost::swap_test_class::reset();
  boost::swap(object1,object2);

--- a/test/swap/swap_specialized_in_boost_and_other.cpp
+++ b/test/swap/swap_specialized_in_boost_and_other.cpp
@@ -10,7 +10,7 @@
 // in an other namespace to have a custom swap function in boost, because the
 // boost::swap utility should find the swap function in the other namespace, by
 // argument dependent lookup (ADL). Unfortunately ADL isn't fully implemented
-// by some specific compiler versions, including Intel C++ 8.1, MSVC 7.1, and 
+// by some specific compiler versions, including Intel C++ 8.1, MSVC 7.1, and
 // Borland 5.9.3. Users of those compilers might consider adding a swap overload
 // to the boost namespace.

@@ -50,13 +50,13 @@ int main()

  other::swap_test_class object1 = initial_value1;
  other::swap_test_class object2 = initial_value2;
-  
+
  other::swap_test_class::reset();
  boost::swap(object1,object2);

  BOOST_CHECK(object1 == initial_value2);
  BOOST_CHECK(object2 == initial_value1);
-  
+
  BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
  BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);

--- a/test/swap/swap_specialized_in_global.cpp
+++ b/test/swap/swap_specialized_in_global.cpp
@@ -25,13 +25,13 @@ int main()

  swap_test_class object1 = initial_value1;
  swap_test_class object2 = initial_value2;
-  
+
  swap_test_class::reset();
  boost::swap(object1,object2);

  BOOST_CHECK(object1 == initial_value2);
  BOOST_CHECK(object2 == initial_value1);
-  
+
  BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
  BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);

--- a/test/swap/swap_specialized_in_other.cpp
+++ b/test/swap/swap_specialized_in_other.cpp
@@ -31,13 +31,13 @@ int main()

  other::swap_test_class object1 = initial_value1;
  other::swap_test_class object2 = initial_value2;
-  
+
  other::swap_test_class::reset();
  boost::swap(object1,object2);

  BOOST_CHECK(object1 == initial_value2);
  BOOST_CHECK(object2 == initial_value1);
-  
+
  BOOST_CHECK_EQUAL(other::swap_test_class::swap_count(),1);
  BOOST_CHECK_EQUAL(other::swap_test_class::copy_count(),0);

--- a/test/swap/swap_specialized_in_std.cpp
+++ b/test/swap/swap_specialized_in_std.cpp
@@ -30,13 +30,13 @@ int main()

  swap_test_class object1 = initial_value1;
  swap_test_class object2 = initial_value2;
-  
+
  swap_test_class::reset();
  boost::swap(object1,object2);

  BOOST_CHECK(object1 == initial_value2);
  BOOST_CHECK(object2 == initial_value1);
-  
+
  BOOST_CHECK_EQUAL(swap_test_class::swap_count(),1);
  BOOST_CHECK_EQUAL(swap_test_class::copy_count(),0);

--- a/test/swap/swap_std_typeinfo_ptr.cpp
+++ b/test/swap/swap_std_typeinfo_ptr.cpp
@@ -19,7 +19,7 @@ int main()
 {
  const std::type_info * const initial_value1 = 0;
  const std::type_info * const initial_value2 = &typeid(double);
-  
+
  const std::type_info * ptr1 = initial_value1;
  const std::type_info * ptr2 = initial_value2;

--- a/test/swap/swap_std_vector_of_boost.cpp
+++ b/test/swap/swap_std_vector_of_boost.cpp
@@ -5,7 +5,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)

 // Tests swapping std::vector objects by means of boost::swap,
-// having boost::swap_test_class as vector element type. 
+// having boost::swap_test_class as vector element type.

 #include <boost/utility/swap.hpp>
 #include <boost/core/lightweight_test.hpp>
@@ -39,12 +39,12 @@ int main()

  const vector_type initial_value1(initial_size1, swap_test_class_type(1));
  const vector_type initial_value2(initial_size2, swap_test_class_type(2));
-  
+
  vector_type object1 = initial_value1;
  vector_type object2 = initial_value2;

  swap_test_class_type::reset();
-  
+
  boost::swap(object1,object2);

  BOOST_CHECK_EQUAL(object1.size(),initial_size2);
@@ -52,7 +52,7 @@ int main()

  BOOST_CHECK(object1 == initial_value2);
  BOOST_CHECK(object2 == initial_value1);
-  
+
  BOOST_CHECK_EQUAL(swap_test_class_type::swap_count(),0);
  BOOST_CHECK_EQUAL(swap_test_class_type::copy_count(),0);

--- a/test/swap/swap_std_vector_of_global.cpp
+++ b/test/swap/swap_std_vector_of_global.cpp
@@ -5,7 +5,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)

 // Tests swapping std::vector objects by means of boost::swap,
-// having ::swap_test_class as vector element type. 
+// having ::swap_test_class as vector element type.

 #include <boost/utility/swap.hpp>
 #include <boost/core/lightweight_test.hpp>
@@ -17,7 +17,7 @@
 //Put test class in the global namespace
 #include "./swap_test_class.hpp"

-//Provide swap function in the global namespace 
+//Provide swap function in the global namespace
 void swap(swap_test_class& left, swap_test_class& right)
 {
  left.swap(right);
@@ -32,12 +32,12 @@ int main()

  const vector_type initial_value1(initial_size1, swap_test_class(1));
  const vector_type initial_value2(initial_size2, swap_test_class(2));
-  
+
  vector_type object1 = initial_value1;
  vector_type object2 = initial_value2;

  swap_test_class::reset();
-  
+
  boost::swap(object1,object2);

  BOOST_CHECK_EQUAL(object1.size(),initial_size2);
--- a/test/swap/swap_std_vector_of_other.cpp
+++ b/test/swap/swap_std_vector_of_other.cpp
@@ -5,7 +5,7 @@
 // http://www.boost.org/LICENSE_1_0.txt)

 // Tests swapping std::vector objects by means of boost::swap,
-// having other::swap_test_class as vector element type. 
+// having other::swap_test_class as vector element type.

 #include <boost/utility/swap.hpp>
 #include <boost/core/lightweight_test.hpp>
@@ -39,12 +39,12 @@ int main()

  const vector_type initial_value1(initial_size1, swap_test_class_type(1));
  const vector_type initial_value2(initial_size2, swap_test_class_type(2));
-  
+
  vector_type object1 = initial_value1;
  vector_type object2 = initial_value2;

  swap_test_class_type::reset();
-  
+
  boost::swap(object1,object2);

  BOOST_CHECK_EQUAL(object1.size(),initial_size2);
--- a/test/swap/swap_test_class.hpp
+++ b/test/swap/swap_test_class.hpp
@@ -59,7 +59,7 @@ public:
  {
    m_data = arg;
  }
-  
+
  static unsigned int swap_count(){ return swapCount(); }
  static unsigned int copy_count(){ return copyCount(); }
  static unsigned int construct_count(){ return constructCount(); }
@@ -68,7 +68,7 @@ public:
  static void reset()
  {
    swapCount() = 0;
-    copyCount() = 0;    
+    copyCount() = 0;
    constructCount() = 0;
    destructCount() = 0;
  }
@@ -80,19 +80,19 @@ private:
    return value;
  }

-  static unsigned int& copyCount()    
+  static unsigned int& copyCount()
  {
    static unsigned int value = 0;
    return value;
  }

-  static unsigned int& constructCount()    
+  static unsigned int& constructCount()
  {
    static unsigned int value = 0;
    return value;
  }

-  static unsigned int& destructCount()    
+  static unsigned int& destructCount()
  {
    static unsigned int value = 0;
    return value;
--- a/test/underlying_type.cpp
+++ b/test/underlying_type.cpp
@@ -15,7 +15,7 @@
 #include <boost/core/underlying_type.hpp>
 #include <boost/core/scoped_enum.hpp>
 #include <boost/core/lightweight_test_trait.hpp>
-#include <boost/core/is_same.hpp>
+#include <boost/type_traits/is_same.hpp>
 #include <boost/config.hpp>

 #if defined(_MSC_VER)
@@ -63,9 +63,9 @@ struct underlying_type< native_enum >

 int main(int, char*[])
 {
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same< boost::underlying_type< emulated_enum >::type, unsigned char >));
+    BOOST_TEST_TRAIT_TRUE((boost::is_same< boost::underlying_type< emulated_enum >::type, unsigned char >));
 #if !defined(BOOST_NO_CXX11_SCOPED_ENUMS)
-    BOOST_TEST_TRAIT_TRUE((boost::core::is_same< boost::underlying_type< native_enum >::type, unsigned short >));
+    BOOST_TEST_TRAIT_TRUE((boost::is_same< boost::underlying_type< native_enum >::type, unsigned short >));
 #endif

    return boost::report_errors();
Author	SHA1	Message	Date
Peter Dimov	f6193acbdf	Document BOOST_CORE_ALIGNOF	2023-01-26 03:01:01 +02:00
Peter Dimov	a504b356d4	Merge branch 'develop' into feature/alignof	2023-01-26 02:02:00 +02:00
Peter Dimov	bd1835f92f	Avoid memory leak in alloc_construct_cxx11_test.cpp, because ASan diagnoses it	2023-01-26 01:10:00 +02:00
Peter Dimov	bfad92e307	Add Drone support	2023-01-25 22:00:41 +02:00
Peter Dimov	ce93055f03	Disable failing tests under g++ -m32	2023-01-25 21:37:26 +02:00
Peter Dimov	39cf1e65a3	Add BOOST_CORE_ALIGNOF	2023-01-25 20:10:31 +02:00
Peter Dimov	642a0cf70e	Update ci.yml	2023-01-25 01:56:57 +02:00
Peter Dimov	d3ed836f75	Document boost::core::launder	2023-01-24 19:40:30 +02:00
Peter Dimov	c4777c309e	Avoid including <new> in core/launder.hpp when not C++17	2023-01-24 18:54:45 +02:00
Peter Dimov	2b3b97c633	Add boost::core::launder	2023-01-24 17:50:45 +02:00
Peter Dimov	ab455ab2f8	Disable -Wdeprecated-declarations for early clang-cl	2023-01-23 05:24:28 +02:00
Peter Dimov	116c6830e0	Add VS2017 clang-cl to Appveyor	2023-01-23 04:13:05 +02:00
Peter Dimov	d8cfc71073	lwt_unattended: disable WER dialog box on crash	2023-01-19 02:35:15 +02:00
Peter Dimov	dd85ed565e	Update CMakeLists.txt	2023-01-12 20:53:52 +02:00
Peter Dimov	58fd395c51	Merge branch 'develop' of https://github.com/vinniefalco/boost-core into feature/pr-122	2023-01-12 20:51:58 +02:00
Peter Dimov	992824c50b	Update appveyor.yml	2023-01-12 19:55:57 +02:00
Peter Dimov	9d443cb094	Update appveyor.yml	2023-01-12 18:44:30 +02:00
Peter Dimov	7d67301bba	Add CMake tests to Appveyor	2023-01-12 15:25:51 +02:00
Peter Dimov	e487fec094	Merge branch 'develop' into feature/appveyor	2023-01-12 15:23:02 +02:00
Andrey Semashev	0890785fec	Added #pragma once in swap.hpp.	2023-01-07 03:52:46 +03:00
Andrey Semashev	eda68d4086	Trim trailing spaces in boost::swap tests.	2023-01-07 03:42:31 +03:00
Andrey Semashev	8a8738a981	Propagate noexcept specification in boost::swap. Mark boost::swap noexcept if the type supports non-throwing swap implementation.	2023-01-07 03:42:15 +03:00
Andrey Semashev	99f9654f18	Fixed incorrect preprocessor condition for ref_empty definition. Closes https://github.com/boostorg/core/pull/137.	2023-01-07 01:06:41 +03:00
Andrey Semashev	1e84baeea3	Use defaulted template arguments to restrict boost::ref converting ctor.	2023-01-06 19:38:55 +03:00
Andrey Semashev	1825265014	Marked boost::ref methods and associated functions with noexcept.	2023-01-06 19:12:47 +03:00
Peter Dimov	8caca51c4d	Do not run lightweight_test_fail16.cpp under CMake, as CTest doesn't like std::abort	2022-12-30 22:03:06 +02:00
Peter Dimov	2d302c1666	Document boost::core::lwt_init	2022-12-30 21:57:12 +02:00
Peter Dimov	6299da9273	Add boost::core::lwt_init()	2022-12-30 21:17:58 +02:00
Peter Dimov	843e0f7bb0	Add boost::core::detail::lwt_unattended()	2022-12-28 17:49:01 +02:00
Andrey Semashev	ddc6cc25a9	Actualized includes of ref.hpp.	2022-12-22 18:59:27 +03:00
Andrey Semashev	86bf1d4aec	Deprecated boost::core::is_same and the associated header. Moved is_same implementation to detail (both directory and namespace) to use in the public headers and avoid introducing new dependencies. The documentation now recommends users to use Boost.TypeTraits or C++ standard library instead. Also, removed unnecessary includes and added missing ones in a few places.	2022-12-22 17:55:47 +03:00
Andrey Semashev	75c765cc13	Removed suppression of -Wno-deprecated-builtins on clang-15. Boost.TypeTraits was updated to not use the deprecated builtins, so suppressing the warning should no longer be necessary.	2022-12-18 01:03:39 +03:00
Glen Fernandes	2286749f97	Change order of restoration of warning disables in allocator access	2022-12-15 01:08:51 -05:00
Peter Dimov	23fa5d30f3	Merge pull request #133 from boostorg/feature/lwt_remove_snprintf Remove the use of snprintf for trivial formatting in lightweight_test	2022-12-09 18:55:14 +02:00
Andrey Semashev	d428335758	Remove the use of snprintf for trivial formatting. This implements in-place formatting for small hex numbers instead of using snprintf with the associated portability scaffolding. This also removes the need for #include <cstdio>.	2022-12-09 04:15:02 +03:00
Andrey Semashev	be8790115c	Added portable snprintf/vsnprintf definition. This definitions is mostly a workaround for older MSVC versions that only provided non-portable _snprintf etc. that are not fully conforming to the standard snprintf. This implementation fixes its issues wrt. null termination and returned values in case of buffer overflows. On platforms that support the standard snprintf, the definitions in the header are equivalent to the standard functions.	2022-12-09 03:53:01 +03:00
Vinnie Falco	6fb57488a2	add boost_core.natvis and interface project sources	2022-08-19 12:18:32 -07:00
Peter Dimov	003c7365bc	Use VS2019 for clang-win, because VS2017 fails to find msvcrt(d).lib for some reason now	2021-10-05 01:00:09 +03:00