bumping up cmake

.github/workflows/aarch64.yml

@@ -24,6 +24,6 @@ jobs:
             apt-get update -q -y
             apt-get install -y cmake make g++
           run: |
-            cmake -DSIMDJSON_SANITIZE_UNDEFINED=ON -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build
+            cmake -DSIMDJSON_SANITIZE_UNDEFINED=ON -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
             cmake --build build -j=2
             ctest --output-on-failure --test-dir build

.github/workflows/macos.yml

@@ -18,13 +18,13 @@ jobs:
         run: |
           mkdir builddebug &&
           cd builddebug &&
-          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
+          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
           cmake --build .   &&
           ctest --output-on-failure -LE explicitonly -j   &&
           cd .. &&
           mkdir build &&
           cd build &&
-          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
           cmake --build .   &&
           ctest --output-on-failure -LE explicitonly -j   &&
           cmake --install . &&
@@ -35,7 +35,7 @@ jobs:
         run: |
           mkdir buildshared &&
           cd buildshared &&
-          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake  -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX:PATH=destination -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
           cmake --build .   &&
           ctest --output-on-failure -LE explicitonly -j   &&
           cmake --install . &&

.github/workflows/msys2.yml

@@ -43,6 +43,6 @@ jobs:
         run: |
           mkdir build
           cd build
-          cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_BUILD_TYPE=${{ matrix.type }} -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_DO_NOT_USE_THREADS_NO_MATTER_WHAT=ON ..
+          cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_BUILD_TYPE=${{ matrix.type }} -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_DO_NOT_USE_THREADS_NO_MATTER_WHAT=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..
           cmake --build . --verbose
           ctest -j4 --output-on-failure -LE explicitonly

.github/workflows/riscv64.yml

@@ -24,6 +24,6 @@ jobs:
             apt-get update -q -y
             apt-get install -y cmake make g++
           run: |
-            cmake -DCMAKE_BUILD_TYPE=Release -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF  -B build
+            cmake -DCMAKE_BUILD_TYPE=Release -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
             cmake --build build -j=2
             ctest --output-on-failure --test-dir build

.github/workflows/rvv-1024-clang-18.yml

@@ -20,7 +20,7 @@ jobs:
     - name: Build
       run: |
         CC=clang-18 CXX=clang++-18 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvbb" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
         cmake --build build/ -j$(nproc) --config Release
     - name: Test VLEN=1024
       run: |

.github/workflows/rvv-128-clang-20.yml

@@ -20,7 +20,7 @@ jobs:
     - name: Build
       run: |
         CC=clang-20 CXX=clang++-20 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
         cmake --build build/ -j$(nproc) --config Release
     - name: Test VLEN=128
       run: |
@@ -30,7 +30,7 @@ jobs:
     - name: Build VLS
       run: |
         CC=clang-20 CXX=clang++-20 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvl128b_zba_zbb_zbc -mrvv-vector-bits=zvl" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build-vls
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build-vls
         cmake --build build-vls/ -j$(nproc) --config Release
     - name: Test VLEN=128 VLS
       run: |

.github/workflows/rvv-256-gcc-14.yml

@@ -20,7 +20,7 @@ jobs:
     - name: Build
       run: |
         CC=riscv64-linux-gnu-gcc-14 CXX=riscv64-linux-gnu-g++-14 CFLAGS=-march=rv64gcv CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
         cmake --build build/ -j$(nproc) --config Release
     - name: Test VLEN=256
       run: |
@@ -30,7 +30,7 @@ jobs:
     - name: Build VLS
       run: |
         CC=riscv64-linux-gnu-gcc-14 CXX=riscv64-linux-gnu-g++-14 CFLAGS="-march=rv64gcv_zvl256b -mrvv-vector-bits=zvl" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build-vls
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build-vls
         cmake --build build-vls/ -j$(nproc) --config Release
     - name: Test VLEN=256 VLS
       run: |

.github/workflows/rvv-512-clang-19.yml

@@ -20,7 +20,7 @@ jobs:
     - name: Build
       run: |
         CC=clang-19 CXX=clang++-19 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
         cmake --build build/ -j$(nproc) --config Release
     - name: Test VLEN=512
       run: |
@@ -30,7 +30,7 @@ jobs:
     - name: Build VLS
       run: |
         CC=clang-19 CXX=clang++-19 CFLAGS="--target=riscv64-linux-gnu -march=rv64gcv_zvl512b_zba_zbb_zbc -mrvv-vector-bits=zvl" CXXFLAGS="${CFLAGS}" \
-        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -B build-vls
+        cmake --toolchain=cmake/toolchains-ci/riscv64-linux-gnu.cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build-vls
         cmake --build build-vls/ -j$(nproc) --config Release
     - name: Test VLEN=512 VLS
       run: |

.github/workflows/s390x.yml

@@ -24,6 +24,6 @@ jobs:
             apt-get update -q -y
             apt-get install -y cmake make g++
           run: |
-            cmake -DCMAKE_BUILD_TYPE=Release  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build
+            cmake -DCMAKE_BUILD_TYPE=Release  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
             cmake --build build -j=2
             ctest --output-on-failure --test-dir build

.github/workflows/ubuntu22-clang13.yml

@@ -18,6 +18,6 @@ jobs:
         run: |
           mkdir build &&
           cd build &&
-          CXX=clang++-13 cmake -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
+          CXX=clang++-13 cmake -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
           cmake --build .   &&
           ctest --output-on-failure -LE explicitonly -j

.github/workflows/ubuntu22-glibcxxassertions.yml

@@ -19,6 +19,6 @@ jobs:
         run: |
           mkdir build &&
           cd build &&
-          CXX=g++-12 cmake -DCMAKE_BUILD_TYPE=Debug  -DSIMDJSON_GLIBCXX_ASSERTIONS=ON -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON ..  &&
+          CXX=g++-12 cmake -DCMAKE_BUILD_TYPE=Debug  -DSIMDJSON_GLIBCXX_ASSERTIONS=ON -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
           cmake --build .   &&
           ctest . -E avoid_

.github/workflows/ubuntu22-threadsani.yml

@@ -18,7 +18,7 @@ jobs:
         run: |
           mkdir build &&
           cd build &&
-          CXX=g++-12 cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE_THREADS=ON ..  &&
+          CXX=g++-12 cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE_THREADS=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
           cmake --build . --target document_stream_tests  --target ondemand_document_stream_tests --target parse_many_test  &&
           ctest --output-on-failure  -R parse_many_test  &&
           ctest --output-on-failure  -R document_stream_tests

.github/workflows/ubuntu24-checkperf.yml

@@ -24,6 +24,6 @@ jobs:
         run: |
           mkdir build &&
           cd build &&
-          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_ENABLE_DOM_CHECKPERF=ON -DCMAKE_CXX_FLAGS="-Werror=old-style-cast -pedantic -Wpedantic" -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_ENABLE_DOM_CHECKPERF=ON -DCMAKE_CXX_FLAGS="-Werror=old-style-cast -pedantic -Wpedantic" -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
           cmake --build . --target checkperf  &&
           ctest --output-on-failure -R checkperf

.github/workflows/ubuntu24-cxx20-noexcept.yml

@@ -13,7 +13,7 @@ jobs:
     steps:
       - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
       - name: Prepare
-        run: cmake -DSIMDJSON_CXX_STANDARD=20 -DSIMDJSON_EXCEPTIONS=OFF -DSIMDJSON_DEVELOPER_MODE=ON  -B build
+        run: cmake -DSIMDJSON_CXX_STANDARD=20 -DSIMDJSON_EXCEPTIONS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
         env:
           CXX: ${{matrix.cxx}}
       - name: Build

.github/workflows/ubuntu24-cxx20.yml

@@ -13,7 +13,7 @@ jobs:
     steps:
       - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
       - name: Prepare
-        run: cmake -DSIMDJSON_CXX_STANDARD=20 -DSIMDJSON_DEVELOPER_MODE=ON  -B build
+        run: cmake -DSIMDJSON_CXX_STANDARD=20 -DSIMDJSON_DEVELOPER_MODE=ON -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
         env:
           CXX: ${{matrix.cxx}}
       - name: Build

.github/workflows/ubuntu24-noexcept.yml

@@ -18,13 +18,13 @@ jobs:
         run: |
           mkdir builddebug &&
           cd builddebug &&
-          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF ..  &&
+          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
           cmake --build .   &&
           ctest --output-on-failure -LE explicitonly -j   &&
           cd .. &&
           mkdir build &&
           cd build &&
-          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_EXCEPTIONS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
           cmake --build .   &&
           ctest --output-on-failure -LE explicitonly -j   &&
           make install  &&

.github/workflows/ubuntu24-nothread.yml

@@ -18,13 +18,13 @@ jobs:
         run: |
           mkdir builddebug &&
           cd builddebug &&
-          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF  -DSIMDJSON_ENABLE_THREADS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
+          cmake -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF  -DSIMDJSON_ENABLE_THREADS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
           cmake --build .   &&
           ctest --output-on-failure -LE explicitonly -j   &&
           cd .. &&
           mkdir build &&
           cd build &&
-          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_ENABLE_THREADS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake  -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_ENABLE_THREADS=OFF -DBUILD_SHARED_LIBS=OFF -DCMAKE_INSTALL_PREFIX:PATH=destination -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
           cmake --build .   &&
           ctest --output-on-failure -LE explicitonly -j   &&
           make install  &&

.github/workflows/ubuntu24-sani.yml

@@ -18,7 +18,7 @@ jobs:
         run: |
           mkdir builddebug &&
           cd builddebug &&
-          cmake -DSIMDJSON_SANITIZE=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
+          cmake -DSIMDJSON_SANITIZE=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
           cmake --build .   &&
           ctest --output-on-failure -LE explicitonly -j
   ubuntu-build-undefined-sanitizer:
@@ -36,6 +36,6 @@ jobs:
         run: |
           mkdir builddebugundefsani &&
           cd builddebugundefsani &&
-          cmake -DSIMDJSON_SANITIZE_UNDEFINED=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
+          cmake -DSIMDJSON_SANITIZE_UNDEFINED=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON ..  &&
           cmake --build .   &&
           ctest --output-on-failure -LE explicitonly -j

.github/workflows/ubuntu24.yml

@@ -16,10 +16,10 @@ jobs:
     steps:
       - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
       - name: Prepare
-        run: cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE=${{matrix.sanitizer}} -DBUILD_SHARED_LIBS=${{matrix.shared}}  -B build
+        run: cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE=${{matrix.sanitizer}} -DBUILD_SHARED_LIBS=${{matrix.shared}} -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
         env:
           CXX: ${{matrix.cxx}}
       - name: Build
         run: cmake --build build -j=2
       - name: Test
-        run: ctest --output-on-failure --test-dir build
+        run: ctest --output-on-failure --test-dir build

.github/workflows/vs17-arm-ci.yml

@@ -17,5 +17,5 @@ jobs:
          uses: actions/checkout@v4
        - name: Use cmake
          run: |
-           cmake -A ${{ matrix.arch }} -DCMAKE_SYSTEM_VERSION="10.0.22621.0" -DCMAKE_CROSSCOMPILING=1 -DSIMDJSON_DEVELOPER_MODE=ON -D SIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_EXCEPTIONS=OFF -B build  &&
+           cmake -A ${{ matrix.arch }} -DCMAKE_SYSTEM_VERSION="10.0.22621.0" -DCMAKE_CROSSCOMPILING=1 -DSIMDJSON_DEVELOPER_MODE=ON -D SIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_EXCEPTIONS=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build  &&
            cmake --build build --verbose

.github/workflows/vs17-ci-cxx20.yml

@@ -22,7 +22,7 @@ jobs:
       uses: actions/checkout@v4
     - name: Configure
       run: |
-        cmake -DSIMDJSON_CXX_STANDARD=20 -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build
+        cmake -DSIMDJSON_CXX_STANDARD=20 -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
     - name: Build Debug
       run: cmake --build build --config Debug --verbose
     - name: Build Release

.github/workflows/vs17-clang-ci-cxx20.yml

@@ -21,7 +21,7 @@ jobs:
       uses: actions/checkout@v4
     - name: Configure
       run: |
-        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -T ClangCL -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -B build
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -T ClangCL -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -B build
     - name: Build
       run: cmake --build build --config ${{matrix.build_type}} --verbose
     - name: Run tests

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.14)
+cmake_minimum_required(VERSION 3.24)
 
 # Build performance optimizations
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON CACHE BOOL "Export compile commands for faster IDE integration")
@@ -12,7 +12,7 @@ endif()
 project(
     simdjson
     # The version number is modified by tools/release.py
-    VERSION 4.6.1
+    VERSION 4.4.2
     DESCRIPTION "Parsing gigabytes of JSON per second"
     HOMEPAGE_URL "https://simdjson.org/"
     LANGUAGES CXX C
@@ -29,8 +29,8 @@ string(
 # ---- Options, variables ----
 
 # These version numbers are modified by tools/release.py
-set(SIMDJSON_LIB_VERSION "33.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "33" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_LIB_VERSION "31.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_SOVERSION "31" CACHE STRING "simdjson library soversion")
 
 option(SIMDJSON_BUILD_STATIC_LIB "Build simdjson_static library along with simdjson (only makes sense if BUILD_SHARED_LIBS=ON)" OFF)
 if(SIMDJSON_BUILD_STATIC_LIB AND NOT BUILD_SHARED_LIBS)
@@ -76,12 +76,9 @@ if(SIMDJSON_DEVELOPMENT_CHECKS)
 endif()
 
 if(is_top_project)
-  option(SIMDJSON_INSTALL "Enable target install" ON)
   option(SIMDJSON_DEVELOPER_MODE "Enable targets for developing simdjson" OFF)
   option(BUILD_SHARED_LIBS "Build simdjson as a shared library" OFF)
   option(SIMDJSON_SINGLEHEADER "Disable singleheader generation" ON)
-else()
-  option(SIMDJSON_INSTALL "Enable target install" ${BUILD_SHARED_LIBS})
 endif()
 
 include(cmake/handle-deprecations.cmake)
@@ -95,16 +92,13 @@ add_library(simdjson ${SIMDJSON_SOURCES})
 add_library(simdjson::simdjson ALIAS simdjson)
 set(SIMDJSON_LIBRARIES simdjson)
 
-# Check for <bit> header compatibility
-include(CheckIncludeFileCXX)
-check_include_file_cxx(bit SIMDJSON_HAS_BIT_HEADER)
-
 # Enable precompiled headers for faster builds
 if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.16")
-  set(SIMDJSON_PRECOMPILE_HEADERS
+  target_precompile_headers(simdjson PRIVATE
     <algorithm>
     <array>
     <atomic>
+    <bit>
     <cassert>
     <cctype>
     <cerrno>
@@ -117,12 +111,6 @@ if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.16")
     <utility>
     <vector>
   )
-
-  if(SIMDJSON_HAS_BIT_HEADER)
-    list(APPEND SIMDJSON_PRECOMPILE_HEADERS <bit>)
-  endif()
-
-  target_precompile_headers(simdjson PRIVATE ${SIMDJSON_PRECOMPILE_HEADERS})
 endif()
 
 if(SIMDJSON_BUILD_STATIC_LIB)
@@ -167,37 +155,13 @@ if(MSVC)
   endif()
 endif()
 
-
-
 if(SIMDJSON_STATIC_REFLECTION)
-
-
-  if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION MATCHES "^21")
-    execute_process(
-        COMMAND ${CMAKE_CXX_COMPILER} --version
-        OUTPUT_VARIABLE CLANG_VERSION_OUTPUT
-        ERROR_VARIABLE CLANG_VERSION_ERROR
-        RESULT_VARIABLE CLANG_VERSION_RESULT
-    )
-    if(CLANG_VERSION_RESULT EQUAL 0 AND CLANG_VERSION_OUTPUT MATCHES "https://github.com/bloomberg/clang-p2996.git")
-        set(IS_BLOOMBERG_P2996_CLANG ON)
-        message(STATUS "Using Bloomberg P2996 Clang fork")
-    endif()
-  endif()
-
   # We would like to require C++26, but no compiler supports that!
   # This is a hack:
-  if(IS_BLOOMBERG_P2996_CLANG)
   simdjson_add_props(
       target_compile_options PUBLIC
       -freflection -fexpansion-statements -stdlib=libc++ -std=c++26
   )
-  else()
-  simdjson_add_props(
-      target_compile_options PUBLIC
-      -freflection -std=c++26
-  )
-  endif()
 else()
   simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
 endif()
@@ -252,89 +216,87 @@ endif()
 
 # ---- Install rules ----
 
-if(SIMDJSON_INSTALL)
-    include(CMakePackageConfigHelpers)
-    include(GNUInstallDirs)
+include(CMakePackageConfigHelpers)
+include(GNUInstallDirs)
 
-    if(SIMDJSON_SINGLEHEADER)
-      install(
-          FILES singleheader/simdjson.h
-          DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
-          COMPONENT simdjson_Development
-      )
-    endif()
-
-    install(
-        TARGETS simdjson
-        EXPORT simdjsonTargets
-        RUNTIME COMPONENT simdjson_Runtime
-        LIBRARY COMPONENT simdjson_Runtime
-        NAMELINK_COMPONENT simdjson_Development
-        ARCHIVE COMPONENT simdjson_Development
-        INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
-    )
-    configure_file(cmake/simdjson-config.cmake.in simdjson-config.cmake @ONLY)
-
-    write_basic_package_version_file(
-        simdjson-config-version.cmake
-        COMPATIBILITY SameMinorVersion
-    )
-
-    set(
-        SIMDJSON_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/simdjson"
-        CACHE STRING "CMake package config location relative to the install prefix"
-    )
-    mark_as_advanced(SIMDJSON_INSTALL_CMAKEDIR)
-
-    install(
-        FILES
-        "${PROJECT_BINARY_DIR}/simdjson-config.cmake"
-        "${PROJECT_BINARY_DIR}/simdjson-config-version.cmake"
-        DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
-        COMPONENT simdjson_Development
-    )
-
-    install(
-        EXPORT simdjsonTargets
-        NAMESPACE simdjson::
-        DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
-        COMPONENT simdjson_Development
-    )
-
-    if(SIMDJSON_BUILD_STATIC_LIB)
-      install(
-          TARGETS simdjson_static
-          EXPORT simdjson_staticTargets
-          ARCHIVE COMPONENT simdjson_Development
-          INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
-      )
-      install(
-          EXPORT simdjson_staticTargets
-          NAMESPACE simdjson::
-          DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
-          COMPONENT simdjson_Development
-      )
-    endif()
-
-    # pkg-config
-    include(cmake/JoinPaths.cmake)
-    join_paths(PKGCONFIG_INCLUDEDIR "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}")
-    join_paths(PKGCONFIG_LIBDIR "\${prefix}" "${CMAKE_INSTALL_LIBDIR}")
-
-    if(SIMDJSON_ENABLE_THREADS)
-      set(PKGCONFIG_CFLAGS "-DSIMDJSON_THREADS_ENABLED=1")
-      if(CMAKE_THREAD_LIBS_INIT)
-        set(PKGCONFIG_LIBS_PRIVATE "Libs.private: ${CMAKE_THREAD_LIBS_INIT}")
-      endif()
-    endif()
-
-    configure_file("simdjson.pc.in" "simdjson.pc" @ONLY)
-    install(
-        FILES "${CMAKE_CURRENT_BINARY_DIR}/simdjson.pc"
-        DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig"
-    )
+if(SIMDJSON_SINGLEHEADER)
+  install(
+      FILES singleheader/simdjson.h
+      DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+      COMPONENT simdjson_Development
+  )
 endif()
 
+install(
+    TARGETS simdjson
+    EXPORT simdjsonTargets
+    RUNTIME COMPONENT simdjson_Runtime
+    LIBRARY COMPONENT simdjson_Runtime
+    NAMELINK_COMPONENT simdjson_Development
+    ARCHIVE COMPONENT simdjson_Development
+    INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+)
+configure_file(cmake/simdjson-config.cmake.in simdjson-config.cmake @ONLY)
+
+write_basic_package_version_file(
+    simdjson-config-version.cmake
+    COMPATIBILITY SameMinorVersion
+)
+
+set(
+    SIMDJSON_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/simdjson"
+    CACHE STRING "CMake package config location relative to the install prefix"
+)
+mark_as_advanced(SIMDJSON_INSTALL_CMAKEDIR)
+
+install(
+    FILES
+    "${PROJECT_BINARY_DIR}/simdjson-config.cmake"
+    "${PROJECT_BINARY_DIR}/simdjson-config-version.cmake"
+    DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
+    COMPONENT simdjson_Development
+)
+
+install(
+    EXPORT simdjsonTargets
+    NAMESPACE simdjson::
+    DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
+    COMPONENT simdjson_Development
+)
+
+if(SIMDJSON_BUILD_STATIC_LIB)
+  install(
+      TARGETS simdjson_static
+      EXPORT simdjson_staticTargets
+      ARCHIVE COMPONENT simdjson_Development
+      INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+  )
+  install(
+      EXPORT simdjson_staticTargets
+      NAMESPACE simdjson::
+      DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
+      COMPONENT simdjson_Development
+  )
+endif()
+
+# pkg-config
+include(cmake/JoinPaths.cmake)
+join_paths(PKGCONFIG_INCLUDEDIR "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}")
+join_paths(PKGCONFIG_LIBDIR "\${prefix}" "${CMAKE_INSTALL_LIBDIR}")
+
+if(SIMDJSON_ENABLE_THREADS)
+  set(PKGCONFIG_CFLAGS "-DSIMDJSON_THREADS_ENABLED=1")
+  if(CMAKE_THREAD_LIBS_INIT)
+    set(PKGCONFIG_LIBS_PRIVATE "Libs.private: ${CMAKE_THREAD_LIBS_INIT}")
+  endif()
+endif()
+
+configure_file("simdjson.pc.in" "simdjson.pc" @ONLY)
+install(
+    FILES "${CMAKE_CURRENT_BINARY_DIR}/simdjson.pc"
+    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig"
+)
+
 #
 # CPack
 #
@@ -411,25 +373,18 @@ add_subdirectory(fuzz)
 #
 # Source files should be just ASCII
 #
-find_program(FIND_CMD find)
-find_program(FILE_CMD file)
-find_program(GREP_CMD grep)
-if(FIND_CMD AND FILE_CMD AND GREP_CMD)
+find_program(FIND find)
+find_program(FILE file)
+find_program(GREP grep)
+if(FIND AND FILE AND GREP)
   add_test(
       NAME just_ascii
       COMMAND sh -c "\
-non_ascii=$(${FIND_CMD} include src windows tools singleheader tests examples benchmark \
-  -path benchmark/checkperf-reference -prune -name '*.h' -o -name '*.cpp' \
-  -type f -exec ${FILE_CMD} '{}' \; | ${GREP_CMD} -v ASCII); \
-if [ -n \"$non_ascii\" ]; then \
-  echo 'The following files contain non-ASCII characters:'; \
-  echo \"$non_ascii\"; \
-  exit 1; \
-fi"
+${FIND} include src windows tools singleheader tests examples benchmark \
+-path benchmark/checkperf-reference -prune -name '*.h' -o -name '*.cpp' \
+-type f -exec ${FILE} '{}' \; | ${GREP} -qv ASCII || exit 0  && exit 1"
       WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
   )
-else()
-  message(WARNING "just_ascii test disabled because required tools were not found: find='${FIND_CMD}', file='${FILE_CMD}', grep='${GREP_CMD}'")
 endif()
 
 ##

Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = simdjson
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = "4.6.1"
+PROJECT_NUMBER         = "4.4.2"
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

benchmark/partial_tweets/tweet.h

@@ -10,7 +10,7 @@ namespace partial_tweets {
 //     {
 //       "created_at": "Sun Aug 31 00:29:15 +0000 2014",
 //       "id": 505874924095815700,
-//       "text": "@aym0566x ...",
+//       "text": "@aym0566x \n\n名前:前田あゆみ\n第一印象:なんか怖っ！\n今の印象:とりあえずキモい。噛み合わない\n好きなところ:ぶすでキモいとこ😋✨✨\n思い出:んーーー、ありすぎ😊❤️\nLINE交換できる？:あぁ……ごめん✋\nトプ画をみて:照れますがな😘✨\n一言:お前は一生もんのダチ💖",
 //       "in_reply_to_status_id": null,
 //       "user": {
 //         "id": 1186275104,

cmake/developer-options.cmake

@@ -171,7 +171,7 @@ We recommend Visual Studio 2019 or better on a 64-bit system.")
 else()
   target_compile_options(
       simdjson-internal-flags INTERFACE
-      -Werror -Wall -Wextra -Weffc++ -Wsign-compare -Wshadow -Wwrite-strings
+      -Wall -Wextra -Weffc++ -Wsign-compare -Wshadow -Wwrite-strings
       -Wpointer-arith -Winit-self -Wconversion -Wno-sign-conversion
   )
   if(CMAKE_CXX_STANDARD VERSION_GREATER_EQUAL 20)

doc/basics.md

@@ -379,8 +379,6 @@ tracking explicitly potential programming mistakes. Thus you should not relying
 size (`sizeof`) of our data structures to be constant: they may change depending on the
 compiler settings.
 
-When `SIMDJSON_DEVELOPMENT_CHECKS` is set at compile time, the global variable `simdjson_development_checks_enabled` is defined as true. It is false otherwise.
-
 Once your code has been tested, you can then run it in
 Release mode: under Visual Studio, it means having the `_DEBUG` macro undefined, and, for other
 compilers, it means setting `__OPTIMIZE__` to a positive integer. You can also forcefully
@@ -438,7 +436,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
 * **Extracting Values:** You can cast a JSON element to a native type:
   `double(element)`. This works for `std::string_view`, double, uint64_t, int64_t, bool,
   ondemand::object and ondemand::array. We also have explicit methods such as `get_string()`, `get_double()`,
-  `get_uint64()`, `get_int64()`, `get_uint32()`, `get_int32()`, `get_bool()`, `get_object()` and `get_array()`. After a cast or an explicit method,
+  `get_uint64()`, `get_int64()`, `get_bool()`, `get_object()` and `get_array()`. After a cast or an explicit method,
   the number, string or boolean will be parsed, or the initial `{` or `[` will be verified for `ondemand::object` and `ondemand::array`. An exception may be thrown if
   the cast is not possible: the error code is `simdjson::INCORRECT_TYPE` (see [Error handling](#error-handling)). Importantly, when getting an ondemand::object or ondemand::array instance, its content is
   not validated: you are only guaranteed that the corresponding initial character (`{` or `[`) is present. Thus,
@@ -448,8 +446,8 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   pass `true` (`get_string(true)`) as a parameter to get replacement characters where errors
   occur. If you somehow need to access non-UTF-8 strings in a lossless manner
   (e.g., if you strings contain unpaired surrogates), you may use the `get_wobbly_string()` function to get a string in the [WTF-8 format](https://simonsapin.github.io/wtf-8).
-  When calling `get_uint64()`, `get_int64()`, `get_uint32()` or `get_int32()`, if the number does not fit in the
-  corresponding integer type, it is also considered an error (`NUMBER_OUT_OF_RANGE`). When parsing numbers or other scalar values, the library checks
+  When calling `get_uint64()` and `get_int64()`, if the number does not fit in a corresponding
+  64-bit integer type, it is also considered an error. When parsing numbers or other scalar values, the library checks
   that the value is followed by an expected character, thus you *may* get a number parsing error when accessing the digits
   as an integer in the following strings: `{"number":12332a`, `{"number":12332\0`, `{"number":12332` (the digits appear at the end). We always abide by the [RFC 8259](https://www.tbray.org/ongoing/When/201x/2017/12/14/rfc8259.html) JSON specification so that, for example, numbers prefixed by the `+` sign are in error.
 
@@ -1302,6 +1300,10 @@ You can also use the custom `Car` type as part of a template such as `std::vecto
   simdjson::ondemand::parser parser;
   simdjson::ondemand::document doc = parser.iterate(json);
   std::vector<Car> cars(doc);
+  // visual studio users need an explicit call:
+  //   std::vector<Car> cars = doc.get<std::vector<Car>>();
+  // because the compiler does not know whether to convert
+  // doc to an unsigned int or to a vector.
   for(Car& c : cars) {
     std::cout << c.year << std::endl;
   }

doc/dom.md

@@ -168,23 +168,6 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
   `SIMDJSON_MINUS_ZERO_AS_FLOAT` to `1` when building simdjson, you can get that `-0` is mapped to `-0.0`
   as in JavaScript. You can get the desired effect by building simdjson with cmake setting the
   `SIMDJSON_MINUS_ZERO_AS_FLOAT` to on: `cmake -B build -D SIMDJSON_MINUS_ZERO_AS_FLOAT=ON`.
-* **Big Integer Support (opt-in):** By default, integers that exceed the 64-bit range cause parsing to fail with `BIGINT_ERROR`. You can opt in to big integer support so that these numbers are stored as raw digit strings on the tape instead:
-  ```cpp
-  simdjson::dom::parser parser;
-  parser.number_as_string(true); // opt-in, default false
-  simdjson::dom::element doc;
-  auto error = parser.parse("[1, 123456789012345678901]"_padded).get(doc);
-  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
-  for (simdjson::dom::element elem : doc) {
-    if (elem.is_bigint()) {
-      std::string_view digits;
-      error = elem.get_bigint().get(digits);
-      if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
-      std::cout << "big integer: " << digits << std::endl;
-    }
-  }
-  ```
-  When enabled, big integers have type `element_type::BIGINT`. Calling `get_int64()`, `get_uint64()`, or `get_double()` on a big integer returns `INCORRECT_TYPE`. Normal numbers (int64, uint64, double) are unaffected.
 * **Field Access:** To get the value of the "foo" field in an object, use `object["foo"]`.
 * **Array Iteration:** To iterate through an array, use `for (auto value : array) { ... }`. If you
   know the type of the value, you can cast it right there, too! `for (double value : array) { ... }`
@@ -197,7 +180,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
 * **Array and Object size** Given an array or an object, you can get its size (number of elements or keys)
   with the `size()` method.
 * **Checking an Element Type:** You can check an element's type with `element.type()`. It
-  returns an `element_type` with values such as `simdjson::dom::element_type::ARRAY`, `simdjson::dom::element_type::OBJECT`, `simdjson::dom::element_type::INT64`,  `simdjson::dom::element_type::UINT64`,`simdjson::dom::element_type::DOUBLE`, `simdjson::dom::element_type::STRING`, `simdjson::dom::element_type::BOOL`, `simdjson::dom::element_type::NULL_VALUE` or, `simdjson::dom::element_type::BIGINT` (when big integer support is enabled).
+  returns an `element_type` with values such as `simdjson::dom::element_type::ARRAY`, `simdjson::dom::element_type::OBJECT`, `simdjson::dom::element_type::INT64`,  `simdjson::dom::element_type::UINT64`,`simdjson::dom::element_type::DOUBLE`, `simdjson::dom::element_type::STRING`, `simdjson::dom::element_type::BOOL` or, `simdjson::dom::element_type::NULL_VALUE`.
 * **Output to streams and strings:** Given a document or an element (or node) out of a JSON document, you can output a minified string version using the C++ stream idiom (`out << element`). You can also request the construction of a minified string version (`simdjson::minify(element)`) or a prettified string version (`simdjson::prettify(element)`). Numbers are serialized as 64-bit floating-point numbers (`double`).
 
 ### Examples

doc/tape.md

@@ -93,14 +93,6 @@ Float values are represented as two 64-bit tape elements:
 
 Performance consideration: We store numbers of the main tape because we believe that locality of reference is helpful for performance.
 
-## Big Integers
-
-When a JSON integer exceeds the 64-bit range (both signed and unsigned), it is classified as a big integer. By default, parsing returns `BIGINT_ERROR`. When `parser.number_as_string(true)` is set, the raw digits are stored on the string tape using the same format as strings (4-byte little-endian length prefix, followed by the UTF-8 digit bytes, followed by a null terminator).
-
-A big integer is represented on the main tape as the 64-bit tape element `('Z' << 56) + x` where the payload `x` is the location on the string tape of the null-terminated digit string.
-
-For example, the JSON value `99999999999999999999` would be stored as the string `"99999999999999999999"` on the string tape, with a `'Z'` tag on the main tape. Negative big integers include the leading minus sign.
-
 ## Root node
 
 Each JSON document will have two special 64-bit tape elements representing a root node, one at the beginning and one at the end.

examples/quickstart/add_quickstart_test.cmake

@@ -2,13 +2,6 @@
 function(add_quickstart_test TEST_NAME SOURCE_FILE)
   cmake_parse_arguments(PARSE_ARGV 2 ARGS "NO_EXCEPTIONS;NATIVE_ARCH" "" "CXX_STANDARD;LABELS")
 
-  # Standard compiler flags
-  if (MSVC)
-    list(APPEND QUICKSTART_FLAGS /WX)
-  else()
-    list(APPEND QUICKSTART_FLAGS -Werror)
-  endif()
-
   # Native architecture compiler flag
   if (ARGS_NATIVE_ARCH)
     if (MSVC)

fuzz/fuzz_dump.cpp

@@ -54,9 +54,6 @@ static void print_json(std::ostream& os, simdjson::dom::element element) noexcep
   case simdjson::dom::element_type::NULL_VALUE:
     os << "null" << endl;
     break;
-  case simdjson::dom::element_type::BIGINT:
-    os << element.get_bigint().value_unsafe() << endl;
-    break;
   }
 }
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {

include/simdjson/common_defs.h

@@ -297,15 +297,6 @@ namespace std {
 #endif // _MSC_VER
 #endif // SIMDJSON_DEVELOPMENT_CHECKS
 
-
-// Prevent ODR violations for the simdjson_development_checks_enabled variable.
-#if SIMDJSON_DEVELOPMENT_CHECKS
-extern const bool simdjson_development_checks_enabled = true;
-#else
-extern const bool simdjson_development_checks_enabled = false;
-#endif // SIMDJSON_DEVELOPMENT_CHECKS
-
-
 // The SIMDJSON_CHECK_EOF macro is a feature flag for the "don't require padding"
 // feature.
 

include/simdjson/compile_time_json-inl.h

@@ -266,12 +266,6 @@ consteval std::pair<double, size_t> parse_double(const char *src,
 }
 } // namespace number_parsing
 
-consteval auto make_data_member_options(auto&& name_str) {
-  std::meta::data_member_options options{};
-  options.name = std::forward<decltype(name_str)>(name_str);
-  return options;
-}
-
 // JSON string may contain embedded nulls, and C++26 reflection does not yet
 // support std::string_view as a data member type. As a workaround, we define
 // a custom type that holds a const char* and a size.
@@ -326,8 +320,7 @@ using class_type = type_builder<meta_info...>::constructed_type;
 /**
  * @brief Variable template for constructing instances with values
  */
-template <typename T, auto... Vs> constexpr T construct_from = T{Vs...};
-
+template <typename T, auto... Vs> constexpr auto construct_from = T{Vs...};
 
 // in JSON, there are only a few whitespace characters that are allowed
 // outside of objects, arrays, strings, and numbers.
@@ -417,7 +410,7 @@ parse_number(std::string_view json,
         std::from_chars(json.data(), json.data() + json.size(), int_value);
     if (res.ec == std::errc()) {
       out = int_value;
-      if (static_cast<std::size_t>(res.ptr - json.data()) != scope) {
+      if ((res.ptr - json.data()) != scope) {
         simdjson_consteval_error(
             "Internal error: cannot agree on the character range of the float");
       }
@@ -431,7 +424,7 @@ parse_number(std::string_view json,
         std::from_chars(json.data(), json.data() + json.size(), uint_value);
     if (res.ec == std::errc()) {
       out = uint_value;
-      if (static_cast<std::size_t>(res.ptr - json.data()) != scope) {
+      if ((res.ptr - json.data()) != scope) {
         simdjson_consteval_error(
             "Internal error: cannot agree on the character range of the float");
       }
@@ -540,7 +533,7 @@ parse_string(std::string_view json) {
       // present, we have an error (isolated high surrogate), which we
       // tolerate by substituting the substitution_code_point.
       if (end - cursor < 6 || *cursor != '\\' ||
-          *(cursor + 1) != 'u') {
+          *(cursor + 1) != 'u' > 0xFFFF) {
         code_point = substitution_code_point;
       } else {       // we have \u following the high surrogate
         cursor += 2; // skip \u
@@ -894,19 +887,10 @@ parse_json_array_impl(const std::string_view json) {
   std::size_t count = values.size() - 1;
   // We assume all elements have the same type as the first element.
   // However, if the array is heterogeneous, we should use std::variant.
-  auto elem_type = std::meta::type_of(values[1]);
-  // String literals reflected via reflect_constant_string have type const
-  // char[N], but when passed as template auto parameters they decay to
-  // const char*.  Use const char* as the element type so that
-  // construct_from can aggregate-initialize the array.
-  if (std::meta::is_array_type(elem_type) &&
-      std::meta::remove_all_extents(elem_type) == ^^const char) {
-    elem_type = ^^const char *;
-  }
   auto array_type = std::meta::substitute(
       ^^std::array,
       {
-          elem_type, std::meta::reflect_constant(count)});
+          std::meta::type_of(values[1]), std::meta::reflect_constant(count)});
 
   // Create array instance with values
   values[0] = array_type;
@@ -973,7 +957,8 @@ parse_json_object_impl(std::string_view json) {
         simdjson_consteval_error("Expected '}'");
       }
       cursor += object_size;
-      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed), make_data_member_options(field_name));
+      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed),
+                                             {.name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(parsed);
 
@@ -982,7 +967,8 @@ parse_json_object_impl(std::string_view json) {
     case '[': {
       std::string_view value(cursor, end);
       auto [parsed, array_size] = parse_json_array_impl(value);
-      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed), make_data_member_options(field_name));
+      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed),
+                                             {.name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(parsed);
       if (*(cursor + array_size - 1) != ']') {
@@ -1003,7 +989,8 @@ parse_json_object_impl(std::string_view json) {
         }
       }
       auto dms =
-          std::meta::data_member_spec(^^const char *, make_data_member_options(field_name));
+          std::meta::data_member_spec(^^const char *, {
+                                                          .name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant_string(value));
       break;
@@ -1014,7 +1001,8 @@ parse_json_object_impl(std::string_view json) {
       }
       cursor += 4;
 
-      auto dms = std::meta::data_member_spec(^^bool, make_data_member_options(field_name));
+      auto dms = std::meta::data_member_spec(^^bool, {
+                                                         .name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant(true));
       break;
@@ -1025,7 +1013,8 @@ parse_json_object_impl(std::string_view json) {
       }
       cursor += 5;
 
-      auto dms = std::meta::data_member_spec(^^bool, make_data_member_options(field_name));
+      auto dms = std::meta::data_member_spec(^^bool, {
+                                                         .name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant(false));
       break;
@@ -1036,7 +1025,9 @@ parse_json_object_impl(std::string_view json) {
       }
       cursor += 4;
 
-      auto dms = std::meta::data_member_spec(^^std::nullptr_t, make_data_member_options(field_name));
+      auto dms = std::meta::data_member_spec(^^std::nullptr_t,
+                                             {
+                                                 .name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant(nullptr));
       break;
@@ -1060,19 +1051,22 @@ parse_json_object_impl(std::string_view json) {
       if (std::holds_alternative<int64_t>(out)) {
         int64_t int_value = std::get<int64_t>(out);
         auto dms =
-            std::meta::data_member_spec(^^int64_t, make_data_member_options(field_name));
+            std::meta::data_member_spec(^^int64_t, {
+                                                       .name = field_name});
         members.push_back(std::meta::reflect_constant(dms));
         values.push_back(std::meta::reflect_constant(int_value));
       } else if (std::holds_alternative<uint64_t>(out)) {
         uint64_t uint_value = std::get<uint64_t>(out);
         auto dms =
-            std::meta::data_member_spec(^^uint64_t, make_data_member_options(field_name));
+            std::meta::data_member_spec(^^uint64_t, {
+                                                        .name = field_name});
         members.push_back(std::meta::reflect_constant(dms));
         values.push_back(std::meta::reflect_constant(uint_value));
       } else {
         double float_value = std::get<double>(out);
         auto dms =
-            std::meta::data_member_spec(^^double, make_data_member_options(field_name));
+            std::meta::data_member_spec(^^double, {
+                                                      .name = field_name});
         members.push_back(std::meta::reflect_constant(dms));
         values.push_back(std::meta::reflect_constant(float_value));
       }
@@ -1117,11 +1111,16 @@ template <constevalutil::fixed_string json_str> consteval auto parse_json() {
                 "Only JSON objects and arrays are supported at the top level, this "
                 "limitation will be lifted in the future.");*/
 
-  if constexpr (json.front() == '[') {
-    return [: parse_json_array_impl(json).first :];
-  } else {
-    return [: parse_json_object_impl(json).first :];
-  }
+  constexpr auto result = json.front() == '['
+                              ? parse_json_array_impl(json)
+                              : parse_json_object_impl(json);
+  return [: result.first :];
+  /*
+  if(json.front() == '[') {
+      return [:parse_json_array_impl(json).first:];
+  } else if(json.front() == '{') {
+   //   return [:parse_json_object_impl(json).first:];
+  }*/
 }
 
 } // namespace compile_time

include/simdjson/constevalutil.h

@@ -58,11 +58,6 @@ struct fixed_string {
             data[i] = str[i];
         }
     }
-    constexpr fixed_string(const unsigned char (&str)[N])  {
-        for (std::size_t i = 0; i < N; ++i) {
-            data[i] = static_cast<char>(str[i]);
-        }
-    }
     char data[N];
     constexpr std::string_view view() const { return {data, N - 1}; }
     constexpr size_t size() const { return N ; }

include/simdjson/dom/document-inl.h

@@ -141,15 +141,6 @@ inline bool document::dump_raw_tape(std::ostream &os) const noexcept {
     case 'r': // we start and end with the root node
       // should we be hitting the root node?
       return false;
-    case 'Z': // we have a big integer
-      os << "bigint ";
-      std::memcpy(&string_length, string_buf.get() + payload, sizeof(uint32_t));
-      os << std::string_view(
-        reinterpret_cast<const char *>(string_buf.get() + payload + sizeof(uint32_t)),
-        string_length
-      );
-      os << '\n';
-      break;
     default:
       return false;
     }

include/simdjson/dom/element-inl.h

@@ -81,10 +81,6 @@ simdjson_inline simdjson_result<bool> simdjson_result<dom::element>::get_bool()
   if (error()) { return error(); }
   return first.get_bool();
 }
-simdjson_inline simdjson_result<std::string_view> simdjson_result<dom::element>::get_bigint() const noexcept {
-  if (error()) { return error(); }
-  return first.get_bigint();
-}
 
 simdjson_inline bool simdjson_result<dom::element>::is_array() const noexcept {
   return !error() && first.is_array();
@@ -114,9 +110,6 @@ simdjson_inline bool simdjson_result<dom::element>::is_bool() const noexcept {
 simdjson_inline bool simdjson_result<dom::element>::is_null() const noexcept {
   return !error() && first.is_null();
 }
-simdjson_inline bool simdjson_result<dom::element>::is_bigint() const noexcept {
-  return !error() && first.is_bigint();
-}
 
 simdjson_inline simdjson_result<dom::element> simdjson_result<dom::element>::operator[](std::string_view key) const noexcept {
   if (error()) { return error(); }
@@ -225,15 +218,6 @@ inline simdjson_result<bool> element::get_bool() const noexcept {
   }
   return INCORRECT_TYPE;
 }
-inline simdjson_result<std::string_view> element::get_bigint() const noexcept {
-  SIMDJSON_DEVELOPMENT_ASSERT(tape.usable());
-  switch (tape.tape_ref_type()) {
-    case internal::tape_type::BIGINT:
-      return tape.get_string_view();
-    default:
-      return INCORRECT_TYPE;
-  }
-}
 inline simdjson_result<const char *> element::get_c_str() const noexcept {
   SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914
   switch (tape.tape_ref_type()) {
@@ -376,10 +360,6 @@ inline bool element::is_null() const noexcept {
   return tape.is_null_on_tape();
 }
 
-inline bool element::is_bigint() const noexcept {
-  return tape.tape_ref_type() == internal::tape_type::BIGINT;
-}
-
 #if SIMDJSON_EXCEPTIONS
 
 inline element::operator bool() const noexcept(false) { return get<bool>(); }
@@ -512,8 +492,6 @@ inline std::ostream& operator<<(std::ostream& out, element_type type) {
       return out << "bool";
     case element_type::NULL_VALUE:
       return out << "null";
-    case element_type::BIGINT:
-      return out << "bigint";
     default:
       return out << "unexpected content!!!"; // abort() usage is forbidden in the library
   }

include/simdjson/dom/element.h

@@ -21,8 +21,7 @@ enum class element_type {
   DOUBLE = 'd',    ///< double: Any number with a "." or "e" that fits in double.
   STRING = '"',    ///< std::string_view
   BOOL = 't',      ///< bool
-  NULL_VALUE = 'n', ///< null
-  BIGINT = 'Z'     ///< std::string_view: big integer stored as raw digit string
+  NULL_VALUE = 'n' ///< null
 };
 
 /**
@@ -121,14 +120,6 @@ public:
    */
   inline simdjson_result<bool> get_bool() const noexcept;
 
-  /**
-   * Read this element as a big integer (raw digit string).
-   *
-   * @returns A string_view of the raw digits, or:
-   *          INCORRECT_TYPE if the JSON element is not a big integer.
-   */
-  inline simdjson_result<std::string_view> get_bigint() const noexcept;
-
   /**
    * Whether this element is a json array.
    *
@@ -184,11 +175,6 @@ public:
    */
   inline bool is_null() const noexcept;
 
-  /**
-   * Whether this element is a big integer (number exceeding 64-bit range).
-   */
-  inline bool is_bigint() const noexcept;
-
   /**
    * Tell whether the value can be cast to provided type (T).
    *
@@ -547,7 +533,6 @@ public:
   simdjson_inline simdjson_result<uint64_t> get_uint64() const noexcept;
   simdjson_inline simdjson_result<double> get_double() const noexcept;
   simdjson_inline simdjson_result<bool> get_bool() const noexcept;
-  simdjson_inline simdjson_result<std::string_view> get_bigint() const noexcept;
 
   simdjson_inline bool is_array() const noexcept;
   simdjson_inline bool is_object() const noexcept;
@@ -558,7 +543,6 @@ public:
   simdjson_inline bool is_number() const noexcept;
   simdjson_inline bool is_bool() const noexcept;
   simdjson_inline bool is_null() const noexcept;
-  simdjson_inline bool is_bigint() const noexcept;
 
   simdjson_inline simdjson_result<dom::element> operator[](std::string_view key) const noexcept;
   simdjson_inline simdjson_result<dom::element> operator[](const char *key) const noexcept;

include/simdjson/dom/parser-inl.h

@@ -36,11 +36,10 @@ inline bool parser::dump_raw_tape(std::ostream &os) const noexcept {
 }
 
 inline simdjson_result<size_t> parser::read_file(std::string_view path) noexcept {
-  const std::string path_copy(path);
   // Open the file
   SIMDJSON_PUSH_DISABLE_WARNINGS
   SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe
-  std::FILE *fp = std::fopen(path_copy.c_str(), "rb");
+  std::FILE *fp = std::fopen(path.data(), "rb");
   SIMDJSON_POP_DISABLE_WARNINGS
 
   if (fp == nullptr) {
@@ -133,7 +132,6 @@ inline simdjson_result<element> parser::parse_into_document(document& provided_d
     buf += 3;
     len -= 3;
   }
-  implementation->_number_as_string = _number_as_string;
   _error = implementation->parse(buf, len, provided_doc);
 
   if (_error) { return _error; }

include/simdjson/dom/parser.h

@@ -610,13 +610,6 @@ public:
   inline bool dump_raw_tape(std::ostream &os) const noexcept;
 
 
-  /**
-   * When enabled, big integers (exceeding uint64 range) are stored as strings
-   * in the tape instead of returning BIGINT_ERROR. Default: false.
-   */
-  inline void number_as_string(bool enabled) noexcept { _number_as_string = enabled; }
-  inline bool number_as_string() const noexcept { return _number_as_string; }
-
 private:
   /**
    * The maximum document length this parser will automatically support.
@@ -625,9 +618,6 @@ private:
    */
   size_t _max_capacity;
 
-  /** Whether to store big integers as strings instead of returning BIGINT_ERROR */
-  bool _number_as_string{false};
-
   /**
    * The loaded buffer (reused each time load() is called)
    */

include/simdjson/dom/serialization-inl.h

@@ -460,12 +460,6 @@ inline void string_builder<serializer>::append(simdjson::dom::element value) {
     case tape_type::STRING:
       format.string(iter.get_string_view());
       break;
-    case tape_type::BIGINT: {
-      // Big integer stored as string — output raw digits (no quotes)
-      auto sv = iter.get_string_view();
-      format.chars(sv.data(), sv.data() + sv.size());
-      break;
-    }
     case tape_type::INT64:
       format.number(iter.next_tape_value<int64_t>());
       iter.json_index++; // numbers take up 2 spots, so we need to increment

include/simdjson/generic/builder/json_builder.h

@@ -22,7 +22,7 @@ namespace SIMDJSON_IMPLEMENTATION {
 namespace builder {
 
 template <class T>
-  requires(concepts::container_but_not_string<T> && ! concepts::optional_type<T> && !require_custom_serialization<T>)
+  requires(concepts::container_but_not_string<T> && !require_custom_serialization<T>)
 constexpr void atom(string_builder &b, const T &t) {
   auto it = t.begin();
   auto end = t.end();
@@ -130,7 +130,7 @@ template <typename T>
   requires(std::is_enum_v<T> && !require_custom_serialization<T>)
 void atom(string_builder &b, const T &e) {
 #if SIMDJSON_STATIC_REFLECTION
-  static constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
+  constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
   template for (constexpr auto enum_val : enumerators) {
     constexpr auto enum_str = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(enum_val)));
     if (e == [:enum_val:]) {
@@ -294,23 +294,30 @@ string_builder& operator<<(string_builder& b, const Z& z) {
 template<constevalutil::fixed_string... FieldNames, typename T>
   requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))
 void extract_from(string_builder &b, const T &obj) {
+  // Helper to check if a field name matches any of the requested fields
+  auto should_extract = [](std::string_view field_name) constexpr -> bool {
+    return ((FieldNames.view() == field_name) || ...);
+  };
+
   b.append('{');
   bool first = true;
+
   // Iterate through all members of T using reflection
-  static constexpr auto members = std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()));
-  template for (constexpr auto mem : members) {
+  template for (constexpr auto mem : std::define_static_array(
+      std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {
+
     if constexpr (std::meta::is_public(mem)) {
-      static constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));
+      constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));
 
       // Only serialize this field if it's in our list of requested fields
-      if constexpr (((FieldNames.view() == key) || ...)) {
+      if constexpr (should_extract(key)) {
         if (!first) {
           b.append(',');
         }
         first = false;
 
         // Serialize the key
-        static constexpr auto quoted_key = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(mem)));
+        constexpr auto quoted_key = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(mem)));
         b.append_raw(quoted_key);
         b.append(':');
 

include/simdjson/generic/builder/json_string_builder-inl.h

@@ -505,7 +505,7 @@ simdjson_inline bool string_builder::capacity_check(size_t upcoming_bytes) {
   return is_valid;
 }
 
-inline void string_builder::grow_buffer(size_t desired_capacity) {
+simdjson_inline void string_builder::grow_buffer(size_t desired_capacity) {
   if (!is_valid) {
     return;
   }
@@ -842,7 +842,7 @@ simdjson_inline void string_builder::append(const T &value) {
 #if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS
 // Support for range-based appending (std::ranges::view, etc.)
 template <std::ranges::range R>
-  requires(!std::is_convertible<R, std::string_view>::value && !concepts::optional_type<R> && !require_custom_serialization<R>)
+  requires(!std::is_convertible<R, std::string_view>::value && !require_custom_serialization<R>)
 simdjson_inline void string_builder::append(const R &range) noexcept {
   auto it = std::ranges::begin(range);
   auto end = std::ranges::end(range);

include/simdjson/generic/builder/json_string_builder.h

@@ -171,7 +171,7 @@ public:
 #if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS
   // Support for range-based appending (std::ranges::view, etc.)
   template <std::ranges::range R>
-requires (!std::is_convertible<R, std::string_view>::value && !concepts::optional_type<R> && !require_custom_serialization<R>)
+requires (!std::is_convertible<R, std::string_view>::value && !require_custom_serialization<R>)
   simdjson_inline void append(const R &range) noexcept;
 #endif
   /**
@@ -249,7 +249,7 @@ private:
    * If the allocation fails, is_valid is set to false. We expect
    * that this function would not be repeatedly called.
    */
-  inline void grow_buffer(size_t desired_capacity);
+  simdjson_inline void grow_buffer(size_t desired_capacity);
 
   /**
    * We use this helper function to make sure that is_valid is kept consistent.

include/simdjson/generic/ondemand/document-inl.h

@@ -16,8 +16,6 @@
 #include "simdjson/generic/ondemand/deserialize.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
-#include <limits>
-
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace ondemand {
@@ -133,18 +131,6 @@ simdjson_inline simdjson_result<int64_t> document::get_int64() noexcept {
 simdjson_inline simdjson_result<int64_t> document::get_int64_in_string() noexcept {
   return get_root_value_iterator().get_root_int64_in_string(true);
 }
-simdjson_inline simdjson_result<uint32_t> document::get_uint32() noexcept {
-  uint64_t result;
-  SIMDJSON_TRY(get_uint64().get(result));
-  if (result > (std::numeric_limits<uint32_t>::max)()) { return NUMBER_OUT_OF_RANGE; }
-  return static_cast<uint32_t>(result);
-}
-simdjson_inline simdjson_result<int32_t> document::get_int32() noexcept {
-  int64_t result;
-  SIMDJSON_TRY(get_int64().get(result));
-  if (result > (std::numeric_limits<int32_t>::max)() || result < (std::numeric_limits<int32_t>::min)()) { return NUMBER_OUT_OF_RANGE; }
-  return static_cast<int32_t>(result);
-}
 simdjson_inline simdjson_result<double> document::get_double() noexcept {
   return get_root_value_iterator().get_root_double(true);
 }
@@ -178,8 +164,6 @@ template<> simdjson_inline simdjson_result<std::string_view> document::get() & n
 template<> simdjson_inline simdjson_result<double> document::get() & noexcept { return get_double(); }
 template<> simdjson_inline simdjson_result<uint64_t> document::get() & noexcept { return get_uint64(); }
 template<> simdjson_inline simdjson_result<int64_t> document::get() & noexcept { return get_int64(); }
-template<> simdjson_inline simdjson_result<uint32_t> document::get() & noexcept { return get_uint32(); }
-template<> simdjson_inline simdjson_result<int32_t> document::get() & noexcept { return get_int32(); }
 template<> simdjson_inline simdjson_result<bool> document::get() & noexcept { return get_bool(); }
 template<> simdjson_inline simdjson_result<value> document::get() & noexcept { return get_value(); }
 
@@ -190,8 +174,6 @@ template<> simdjson_warn_unused simdjson_inline error_code document::get(std::st
 template<> simdjson_warn_unused simdjson_inline error_code document::get(double& out) & noexcept { return get_double().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code document::get(uint64_t& out) & noexcept { return get_uint64().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code document::get(int64_t& out) & noexcept { return get_int64().get(out); }
-template<> simdjson_warn_unused simdjson_inline error_code document::get(uint32_t& out) & noexcept { return get_uint32().get(out); }
-template<> simdjson_warn_unused simdjson_inline error_code document::get(int32_t& out) & noexcept { return get_int32().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code document::get(bool& out) & noexcept { return get_bool().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code document::get(value& out) & noexcept { return get_value().get(out); }
 
@@ -522,14 +504,6 @@ simdjson_inline simdjson_result<int64_t> simdjson_result<SIMDJSON_IMPLEMENTATION
   if (error()) { return error(); }
   return first.get_int64_in_string();
 }
-simdjson_inline simdjson_result<uint32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::get_uint32() noexcept {
-  if (error()) { return error(); }
-  return first.get_uint32();
-}
-simdjson_inline simdjson_result<int32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::get_int32() noexcept {
-  if (error()) { return error(); }
-  return first.get_int32();
-}
 simdjson_inline simdjson_result<double> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::get_double() noexcept {
   if (error()) { return error(); }
   return first.get_double();
@@ -653,27 +627,27 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::op
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator uint64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_uint64();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator int64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_int64();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator double() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_double();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator std::string_view() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_string();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_raw_json_string();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator bool() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_bool();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
@@ -757,18 +731,6 @@ simdjson_inline simdjson_result<uint64_t> document_reference::get_uint64() noexc
 simdjson_inline simdjson_result<uint64_t> document_reference::get_uint64_in_string() noexcept { return doc->get_root_value_iterator().get_root_uint64_in_string(false); }
 simdjson_inline simdjson_result<int64_t> document_reference::get_int64() noexcept { return doc->get_root_value_iterator().get_root_int64(false); }
 simdjson_inline simdjson_result<int64_t> document_reference::get_int64_in_string() noexcept { return doc->get_root_value_iterator().get_root_int64_in_string(false); }
-simdjson_inline simdjson_result<uint32_t> document_reference::get_uint32() noexcept {
-  uint64_t result;
-  SIMDJSON_TRY(doc->get_root_value_iterator().get_root_uint64(false).get(result));
-  if (result > (std::numeric_limits<uint32_t>::max)()) { return NUMBER_OUT_OF_RANGE; }
-  return static_cast<uint32_t>(result);
-}
-simdjson_inline simdjson_result<int32_t> document_reference::get_int32() noexcept {
-  int64_t result;
-  SIMDJSON_TRY(doc->get_root_value_iterator().get_root_int64(false).get(result));
-  if (result > (std::numeric_limits<int32_t>::max)() || result < (std::numeric_limits<int32_t>::min)()) { return NUMBER_OUT_OF_RANGE; }
-  return static_cast<int32_t>(result);
-}
 simdjson_inline simdjson_result<double> document_reference::get_double() noexcept { return doc->get_root_value_iterator().get_root_double(false); }
 simdjson_inline simdjson_result<double> document_reference::get_double_in_string() noexcept { return doc->get_root_value_iterator().get_root_double(false); }
 simdjson_inline simdjson_result<std::string_view> document_reference::get_string(bool allow_replacement) noexcept { return doc->get_root_value_iterator().get_root_string(false, allow_replacement); }
@@ -786,8 +748,6 @@ template<> simdjson_inline simdjson_result<std::string_view> document_reference:
 template<> simdjson_inline simdjson_result<double> document_reference::get() & noexcept { return get_double(); }
 template<> simdjson_inline simdjson_result<uint64_t> document_reference::get() & noexcept { return get_uint64(); }
 template<> simdjson_inline simdjson_result<int64_t> document_reference::get() & noexcept { return get_int64(); }
-template<> simdjson_inline simdjson_result<uint32_t> document_reference::get() & noexcept { return get_uint32(); }
-template<> simdjson_inline simdjson_result<int32_t> document_reference::get() & noexcept { return get_int32(); }
 template<> simdjson_inline simdjson_result<bool> document_reference::get() & noexcept { return get_bool(); }
 template<> simdjson_inline simdjson_result<value> document_reference::get() & noexcept { return get_value(); }
 #if SIMDJSON_EXCEPTIONS
@@ -919,14 +879,6 @@ simdjson_inline simdjson_result<int64_t> simdjson_result<SIMDJSON_IMPLEMENTATION
   if (error()) { return error(); }
   return first.get_int64_in_string();
 }
-simdjson_inline simdjson_result<uint32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get_uint32() noexcept {
-  if (error()) { return error(); }
-  return first.get_uint32();
-}
-simdjson_inline simdjson_result<int32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get_int32() noexcept {
-  if (error()) { return error(); }
-  return first.get_int32();
-}
 simdjson_inline simdjson_result<double> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get_double() noexcept {
   if (error()) { return error(); }
   return first.get_double();
@@ -1042,27 +994,27 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_refe
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator uint64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_uint64();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator int64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_int64();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator double() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_double();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator std::string_view() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_string();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_raw_json_string();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator bool() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_bool();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }

include/simdjson/generic/ondemand/document.h

@@ -76,26 +76,6 @@ public:
    * @returns INCORRECT_TYPE If the JSON value is not a 64-bit integer.
    */
   simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
-  /**
-   * Cast this JSON value to a 32-bit unsigned integer.
-   *
-   * Calls get_uint64() and checks that the result fits in a uint32_t.
-   *
-   * @returns A 32-bit unsigned integer.
-   * @returns INCORRECT_TYPE If the JSON value is not an unsigned integer.
-   * @returns NUMBER_OUT_OF_RANGE If the value does not fit in a uint32_t.
-   */
-  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
-  /**
-   * Cast this JSON value to a 32-bit signed integer.
-   *
-   * Calls get_int64() and checks that the result fits in an int32_t.
-   *
-   * @returns A 32-bit signed integer.
-   * @returns INCORRECT_TYPE If the JSON value is not an integer.
-   * @returns NUMBER_OUT_OF_RANGE If the value does not fit in an int32_t.
-   */
-  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
   /**
    * Cast this JSON value to a double.
    *
@@ -319,21 +299,21 @@ public:
    * @returns A signed 64-bit integer.
    * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not a 64-bit unsigned integer.
    */
-  explicit simdjson_inline operator uint64_t() noexcept(false);
+  simdjson_inline operator uint64_t() noexcept(false);
   /**
    * Cast this JSON value to a signed integer.
    *
    * @returns A signed 64-bit integer.
    * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not a 64-bit integer.
    */
-  explicit simdjson_inline operator int64_t() noexcept(false);
+  simdjson_inline operator int64_t() noexcept(false);
   /**
    * Cast this JSON value to a double.
    *
    * @returns A double.
    * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not a valid floating-point number.
    */
-  explicit simdjson_inline operator double() noexcept(false);
+  simdjson_inline operator double() noexcept(false);
   /**
    * Cast this JSON value to a string.
    *
@@ -343,7 +323,7 @@ public:
    *          time it parses a document or when it is destroyed.
    * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not a string.
    */
-  explicit simdjson_inline operator std::string_view() noexcept(false) simdjson_lifetime_bound;
+  simdjson_inline operator std::string_view() noexcept(false) simdjson_lifetime_bound;
   /**
    * Cast this JSON value to a raw_json_string.
    *
@@ -352,14 +332,14 @@ public:
    * @returns A pointer to the raw JSON for the given string.
    * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not a string.
    */
-  explicit simdjson_inline operator raw_json_string() noexcept(false) simdjson_lifetime_bound;
+  simdjson_inline operator raw_json_string() noexcept(false) simdjson_lifetime_bound;
   /**
    * Cast this JSON value to a bool.
    *
    * @returns A bool value.
    * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not true or false.
    */
-  explicit simdjson_inline operator bool() noexcept(false);
+  simdjson_inline operator bool() noexcept(false);
   /**
    * Cast this JSON value to a value when the document is an object or an array.
    *
@@ -849,8 +829,6 @@ public:
   simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
-  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
-  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
   simdjson_inline simdjson_result<double> get_double() noexcept;
   simdjson_inline simdjson_result<double> get_double_in_string() noexcept;
   simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;
@@ -945,12 +923,12 @@ public:
   explicit simdjson_inline operator T() noexcept(false);
   simdjson_inline operator array() & noexcept(false);
   simdjson_inline operator object() & noexcept(false);
-  explicit simdjson_inline operator uint64_t() noexcept(false);
-  explicit simdjson_inline operator int64_t() noexcept(false);
-  explicit simdjson_inline operator double() noexcept(false);
-  explicit simdjson_inline operator std::string_view() noexcept(false);
-  explicit simdjson_inline operator raw_json_string() noexcept(false);
-  explicit simdjson_inline operator bool() noexcept(false);
+  simdjson_inline operator uint64_t() noexcept(false);
+  simdjson_inline operator int64_t() noexcept(false);
+  simdjson_inline operator double() noexcept(false);
+  simdjson_inline operator std::string_view() noexcept(false);
+  simdjson_inline operator raw_json_string() noexcept(false);
+  simdjson_inline operator bool() noexcept(false);
   simdjson_inline operator value() noexcept(false);
 #endif
   simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
@@ -1004,8 +982,6 @@ public:
   simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
-  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
-  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
   simdjson_inline simdjson_result<double> get_double() noexcept;
   simdjson_inline simdjson_result<double> get_double_in_string() noexcept;
   simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;
@@ -1030,12 +1006,12 @@ public:
   explicit simdjson_inline operator T() noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::array() & noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::object() & noexcept(false);
-  explicit simdjson_inline operator uint64_t() noexcept(false);
-  explicit simdjson_inline operator int64_t() noexcept(false);
-  explicit simdjson_inline operator double() noexcept(false);
-  explicit simdjson_inline operator std::string_view() noexcept(false);
-  explicit simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
-  explicit simdjson_inline operator bool() noexcept(false);
+  simdjson_inline operator uint64_t() noexcept(false);
+  simdjson_inline operator int64_t() noexcept(false);
+  simdjson_inline operator double() noexcept(false);
+  simdjson_inline operator std::string_view() noexcept(false);
+  simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
+  simdjson_inline operator bool() noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false);
 #endif
   simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
@@ -1093,8 +1069,6 @@ public:
   simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
-  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
-  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
   simdjson_inline simdjson_result<double> get_double() noexcept;
   simdjson_inline simdjson_result<double> get_double_in_string() noexcept;
   simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;
@@ -1116,12 +1090,12 @@ public:
   explicit simdjson_inline operator T() noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::array() & noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::object() & noexcept(false);
-  explicit simdjson_inline operator uint64_t() noexcept(false);
-  explicit simdjson_inline operator int64_t() noexcept(false);
-  explicit simdjson_inline operator double() noexcept(false);
-  explicit simdjson_inline operator std::string_view() noexcept(false);
-  explicit simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
-  explicit simdjson_inline operator bool() noexcept(false);
+  simdjson_inline operator uint64_t() noexcept(false);
+  simdjson_inline operator int64_t() noexcept(false);
+  simdjson_inline operator double() noexcept(false);
+  simdjson_inline operator std::string_view() noexcept(false);
+  simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
+  simdjson_inline operator bool() noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false);
 #endif
   simdjson_inline simdjson_result<size_t> count_elements() & noexcept;

include/simdjson/generic/ondemand/parser-inl.h

@@ -172,7 +172,7 @@ simdjson_pure simdjson_inline size_t parser::max_depth() const noexcept {
 }
 
 simdjson_inline void parser::set_max_capacity(size_t max_capacity) noexcept {
-  if(max_capacity > dom::MINIMAL_DOCUMENT_CAPACITY) {
+  if(max_capacity < dom::MINIMAL_DOCUMENT_CAPACITY) {
     _max_capacity = max_capacity;
   } else {
     _max_capacity = dom::MINIMAL_DOCUMENT_CAPACITY;

include/simdjson/generic/ondemand/std_deserialize.h

@@ -305,7 +305,7 @@ error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept {
 #if SIMDJSON_STATIC_REFLECTION
   std::string_view str;
   SIMDJSON_TRY(val.get_string().get(str));
-  static constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
+  constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
   template for (constexpr auto enum_val : enumerators) {
     if (str == std::meta::identifier_of(enum_val)) {
       out = [:enum_val:];

include/simdjson/generic/ondemand/value-inl.h

@@ -12,8 +12,6 @@
 #include "simdjson/generic/ondemand/value.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
-#include <limits>
-
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace ondemand {
@@ -74,18 +72,6 @@ simdjson_inline simdjson_result<int64_t> value::get_int64() noexcept {
 simdjson_inline simdjson_result<int64_t> value::get_int64_in_string() noexcept {
   return iter.get_int64_in_string();
 }
-simdjson_inline simdjson_result<uint32_t> value::get_uint32() noexcept {
-  uint64_t result;
-  SIMDJSON_TRY(get_uint64().get(result));
-  if (result > (std::numeric_limits<uint32_t>::max)()) { return NUMBER_OUT_OF_RANGE; }
-  return static_cast<uint32_t>(result);
-}
-simdjson_inline simdjson_result<int32_t> value::get_int32() noexcept {
-  int64_t result;
-  SIMDJSON_TRY(get_int64().get(result));
-  if (result > (std::numeric_limits<int32_t>::max)() || result < (std::numeric_limits<int32_t>::min)()) { return NUMBER_OUT_OF_RANGE; }
-  return static_cast<int32_t>(result);
-}
 simdjson_inline simdjson_result<bool> value::get_bool() noexcept {
   return iter.get_bool();
 }
@@ -101,8 +87,6 @@ template<> simdjson_inline simdjson_result<number> value::get() noexcept { retur
 template<> simdjson_inline simdjson_result<double> value::get() noexcept { return get_double(); }
 template<> simdjson_inline simdjson_result<uint64_t> value::get() noexcept { return get_uint64(); }
 template<> simdjson_inline simdjson_result<int64_t> value::get() noexcept { return get_int64(); }
-template<> simdjson_inline simdjson_result<uint32_t> value::get() noexcept { return get_uint32(); }
-template<> simdjson_inline simdjson_result<int32_t> value::get() noexcept { return get_int32(); }
 template<> simdjson_inline simdjson_result<bool> value::get() noexcept { return get_bool(); }
 
 
@@ -114,8 +98,6 @@ template<> simdjson_warn_unused simdjson_inline error_code value::get(number& ou
 template<> simdjson_warn_unused simdjson_inline error_code value::get(double& out) noexcept { return get_double().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code value::get(uint64_t& out) noexcept { return get_uint64().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code value::get(int64_t& out) noexcept { return get_int64().get(out); }
-template<> simdjson_warn_unused simdjson_inline error_code value::get(uint32_t& out) noexcept { return get_uint32().get(out); }
-template<> simdjson_warn_unused simdjson_inline error_code value::get(int32_t& out) noexcept { return get_int32().get(out); }
 template<>  simdjson_warn_unused simdjson_inline error_code value::get(bool& out) noexcept { return get_bool().get(out); }
 
 #if SIMDJSON_EXCEPTIONS
@@ -419,14 +401,6 @@ simdjson_inline simdjson_result<int64_t> simdjson_result<SIMDJSON_IMPLEMENTATION
   if (error()) { return error(); }
   return first.get_int64_in_string();
 }
-simdjson_inline simdjson_result<uint32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get_uint32() noexcept {
-  if (error()) { return error(); }
-  return first.get_uint32();
-}
-simdjson_inline simdjson_result<int32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get_int32() noexcept {
-  if (error()) { return error(); }
-  return first.get_int32();
-}
 simdjson_inline simdjson_result<double> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get_double() noexcept {
   if (error()) { return error(); }
   return first.get_double();

include/simdjson/generic/ondemand/value.h

@@ -161,28 +161,6 @@ public:
    */
   simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
 
-  /**
-   * Cast this JSON value to a 32-bit unsigned integer.
-   *
-   * Calls get_uint64() and checks that the result fits in a uint32_t.
-   *
-   * @returns A 32-bit unsigned integer.
-   * @returns INCORRECT_TYPE If the JSON value is not an unsigned integer.
-   * @returns NUMBER_OUT_OF_RANGE If the value does not fit in a uint32_t.
-   */
-  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
-
-  /**
-   * Cast this JSON value to a 32-bit signed integer.
-   *
-   * Calls get_int64() and checks that the result fits in an int32_t.
-   *
-   * @returns A 32-bit signed integer.
-   * @returns INCORRECT_TYPE If the JSON value is not an integer.
-   * @returns NUMBER_OUT_OF_RANGE If the value does not fit in an int32_t.
-   */
-  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
-
   /**
    * Cast this JSON value to a double.
    *
@@ -768,8 +746,6 @@ public:
   simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64() noexcept;
   simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
-  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
-  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
   simdjson_inline simdjson_result<double> get_double() noexcept;
   simdjson_inline simdjson_result<double> get_double_in_string() noexcept;
   simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;

include/simdjson/internal/dom_parser_implementation.h

@@ -212,12 +212,6 @@ protected:
    */
   size_t _max_depth{0};
 
-public:
-  /** Whether to store big integers as strings instead of returning BIGINT_ERROR */
-  bool _number_as_string{false};
-
-protected:
-
   // Declaring these so that subclasses can use them to implement their constructors.
   simdjson_inline dom_parser_implementation() noexcept;
   simdjson_inline dom_parser_implementation(dom_parser_implementation &&other) noexcept;

include/simdjson/internal/tape_type.h

@@ -19,8 +19,7 @@ enum class tape_type {
   DOUBLE = 'd',
   TRUE_VALUE = 't',
   FALSE_VALUE = 'f',
-  NULL_VALUE = 'n',
-  BIGINT = 'Z'  // Big integer stored as string in string buffer
+  NULL_VALUE = 'n'
 }; // enum class tape_type
 
 } // namespace internal

include/simdjson/padded_string-inl.h

@@ -168,13 +168,10 @@ inline padded_string::operator padded_string_view() const noexcept simdjson_life
 }
 
 inline simdjson_result<padded_string> padded_string::load(std::string_view filename) noexcept {
-  // std::string_view is not guaranteed to be null-terminated, but std::fopen requires
-  // a null-terminated C string. Construct a temporary std::string to ensure null-termination.
-  const std::string null_terminated_filename(filename);
   // Open the file
   SIMDJSON_PUSH_DISABLE_WARNINGS
   SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe
-  std::FILE *fp = std::fopen(null_terminated_filename.c_str(), "rb");
+  std::FILE *fp = std::fopen(filename.data(), "rb");
   SIMDJSON_POP_DISABLE_WARNINGS
 
   if (fp == nullptr) {
@@ -226,13 +223,10 @@ inline simdjson_result<padded_string> padded_string::load(std::string_view filen
 
 #if defined(_WIN32) && SIMDJSON_CPLUSPLUS17
 inline simdjson_result<padded_string> padded_string::load(std::wstring_view filename) noexcept {
-  // std::wstring_view is not guaranteed to be null-terminated, but _wfopen requires
-  // a null-terminated wide C string. Construct a temporary std::wstring to ensure null-termination.
-  const std::wstring null_terminated_filename(filename);
   // Open the file using the wide characters
   SIMDJSON_PUSH_DISABLE_WARNINGS
   SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe
-  std::FILE *fp = _wfopen(null_terminated_filename.c_str(), L"rb");
+  std::FILE *fp = _wfopen(filename.data(), L"rb");
   SIMDJSON_POP_DISABLE_WARNINGS
 
   if (fp == nullptr) {
@@ -355,9 +349,6 @@ inline padded_string padded_string_builder::convert() noexcept {
 }
 
 inline bool padded_string_builder::reserve(size_t additional) noexcept {
-  if (simdjson_unlikely(additional + size < size)) {
-    return false; // overflow: cannot satisfy request
-  }
   size_t needed = size + additional;
   if (needed <= capacity) {
     return true;
@@ -367,9 +358,8 @@ inline bool padded_string_builder::reserve(size_t additional) noexcept {
   // repeated allocations.
   if (new_capacity < 4096) {
     new_capacity *= 2;
-    // overflow guard: ensure new_capacity + new_capacity/2 does not overflow
-  } else if (new_capacity + new_capacity / 2 > new_capacity) {
-    new_capacity += new_capacity / 2; // grow by 1.5x
+  } else {
+    new_capacity += new_capacity/2; // grow by 1.5x
   }
   char *new_data = internal::allocate_padded_buffer(new_capacity);
   if (new_data == nullptr) {

include/simdjson/simdjson_version.h

@@ -4,7 +4,7 @@
 #define SIMDJSON_SIMDJSON_VERSION_H
 
 /** The version of simdjson being used (major.minor.revision) */
-#define SIMDJSON_VERSION "4.6.1"
+#define SIMDJSON_VERSION "4.4.2"
 
 namespace simdjson {
 enum {
@@ -15,11 +15,11 @@ enum {
   /**
    * The minor version (major.MINOR.revision) of simdjson being used.
    */
-  SIMDJSON_VERSION_MINOR = 6,
+  SIMDJSON_VERSION_MINOR = 4,
   /**
    * The revision (major.minor.REVISION) of simdjson being used.
    */
-  SIMDJSON_VERSION_REVISION = 1
+  SIMDJSON_VERSION_REVISION = 2
 };
 } // namespace simdjson
 

jsonexamples/example_config.json

@@ -1,11 +0,0 @@
-{
-  "app_name": "MyApp",
-  "version": "1.0.0",
-  "port": 8080,
-  "debug": true,
-  "features": ["logging", "caching"],
-  "database": {
-    "host": "localhost",
-    "port": 5432
-  }
-}

singleheader/simdjson.cpp

@@ -1,4 +1,4 @@
-/* auto-generated on 2026-04-02 19:14:16 -0400. version 4.6.1 Do not edit! */
+/* auto-generated on 2026-03-20 11:11:38 -0400. version 4.4.2 Do not edit! */
 /* including simdjson.cpp:  */
 /* begin file simdjson.cpp */
 #define SIMDJSON_SRC_SIMDJSON_CPP
@@ -3168,11 +3168,6 @@ struct fixed_string {
             data[i] = str[i];
         }
     }
-    constexpr fixed_string(const unsigned char (&str)[N])  {
-        for (std::size_t i = 0; i < N; ++i) {
-            data[i] = static_cast<char>(str[i]);
-        }
-    }
     char data[N];
     constexpr std::string_view view() const { return {data, N - 1}; }
     constexpr size_t size() const { return N ; }
@@ -7313,12 +7308,6 @@ protected:
    */
   size_t _max_depth{0};
 
-public:
-  /** Whether to store big integers as strings instead of returning BIGINT_ERROR */
-  bool _number_as_string{false};
-
-protected:
-
   // Declaring these so that subclasses can use them to implement their constructors.
   simdjson_inline dom_parser_implementation() noexcept;
   simdjson_inline dom_parser_implementation(dom_parser_implementation &&other) noexcept;
@@ -7894,8 +7883,7 @@ enum class tape_type {
   DOUBLE = 'd',
   TRUE_VALUE = 't',
   FALSE_VALUE = 'f',
-  NULL_VALUE = 'n',
-  BIGINT = 'Z'  // Big integer stored as string in string buffer
+  NULL_VALUE = 'n'
 }; // enum class tape_type
 
 } // namespace internal
@@ -14190,9 +14178,6 @@ struct tape_writer {
   /** Write a double value to tape. */
   simdjson_inline void append_double(double value) noexcept;
 
-  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
-  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
-
   /**
    * Append a tape entry (an 8-bit type,and 56 bits worth of value).
    */
@@ -14276,18 +14261,6 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
   tape_loc = val | ((uint64_t(char(t))) << 56);
 }
 
-simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
-  // Write to string buffer: [4-byte LE length][digits][null]
-  uint32_t str_len = uint32_t(len);
-  memcpy(string_buf, &str_len, sizeof(uint32_t));
-  memcpy(string_buf + sizeof(uint32_t), src, len);
-  string_buf[sizeof(uint32_t) + len] = 0;
-  // Tape entry: offset into string buffer
-  // The caller must set the offset relative to doc.string_buf base
-  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
-  string_buf += sizeof(uint32_t) + len + 1;
-}
-
 } // namespace stage2
 } // unnamed namespace
 } // namespace arm64
@@ -15225,23 +15198,7 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
   iter.log_value("number");
-  error_code err = numberparsing::parse_number(value, tape);
-  if (simdjson_unlikely(err == BIGINT_ERROR &&
-      iter.dom_parser._number_as_string)) {
-    // Write big integer to string buffer using the same format as strings.
-    // Scan digits the same way parse_number does (skip optional '-', then digits).
-    const uint8_t *p = value;
-    if (*p == '-') p++;
-    while (numberparsing::is_digit(*p)) p++;
-    size_t len = size_t(p - value);
-    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
-    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
-    memcpy(dst, value, len);
-    dst += len;
-    on_end_string(dst);
-    return SUCCESS;
-  }
-  return err;
+  return numberparsing::parse_number(value, tape);
 }
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -20582,9 +20539,6 @@ struct tape_writer {
   /** Write a double value to tape. */
   simdjson_inline void append_double(double value) noexcept;
 
-  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
-  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
-
   /**
    * Append a tape entry (an 8-bit type,and 56 bits worth of value).
    */
@@ -20668,18 +20622,6 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
   tape_loc = val | ((uint64_t(char(t))) << 56);
 }
 
-simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
-  // Write to string buffer: [4-byte LE length][digits][null]
-  uint32_t str_len = uint32_t(len);
-  memcpy(string_buf, &str_len, sizeof(uint32_t));
-  memcpy(string_buf + sizeof(uint32_t), src, len);
-  string_buf[sizeof(uint32_t) + len] = 0;
-  // Tape entry: offset into string buffer
-  // The caller must set the offset relative to doc.string_buf base
-  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
-  string_buf += sizeof(uint32_t) + len + 1;
-}
-
 } // namespace stage2
 } // unnamed namespace
 } // namespace haswell
@@ -21617,23 +21559,7 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
   iter.log_value("number");
-  error_code err = numberparsing::parse_number(value, tape);
-  if (simdjson_unlikely(err == BIGINT_ERROR &&
-      iter.dom_parser._number_as_string)) {
-    // Write big integer to string buffer using the same format as strings.
-    // Scan digits the same way parse_number does (skip optional '-', then digits).
-    const uint8_t *p = value;
-    if (*p == '-') p++;
-    while (numberparsing::is_digit(*p)) p++;
-    size_t len = size_t(p - value);
-    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
-    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
-    memcpy(dst, value, len);
-    dst += len;
-    on_end_string(dst);
-    return SUCCESS;
-  }
-  return err;
+  return numberparsing::parse_number(value, tape);
 }
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -26969,9 +26895,6 @@ struct tape_writer {
   /** Write a double value to tape. */
   simdjson_inline void append_double(double value) noexcept;
 
-  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
-  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
-
   /**
    * Append a tape entry (an 8-bit type,and 56 bits worth of value).
    */
@@ -27055,18 +26978,6 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
   tape_loc = val | ((uint64_t(char(t))) << 56);
 }
 
-simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
-  // Write to string buffer: [4-byte LE length][digits][null]
-  uint32_t str_len = uint32_t(len);
-  memcpy(string_buf, &str_len, sizeof(uint32_t));
-  memcpy(string_buf + sizeof(uint32_t), src, len);
-  string_buf[sizeof(uint32_t) + len] = 0;
-  // Tape entry: offset into string buffer
-  // The caller must set the offset relative to doc.string_buf base
-  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
-  string_buf += sizeof(uint32_t) + len + 1;
-}
-
 } // namespace stage2
 } // unnamed namespace
 } // namespace icelake
@@ -28004,23 +27915,7 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
   iter.log_value("number");
-  error_code err = numberparsing::parse_number(value, tape);
-  if (simdjson_unlikely(err == BIGINT_ERROR &&
-      iter.dom_parser._number_as_string)) {
-    // Write big integer to string buffer using the same format as strings.
-    // Scan digits the same way parse_number does (skip optional '-', then digits).
-    const uint8_t *p = value;
-    if (*p == '-') p++;
-    while (numberparsing::is_digit(*p)) p++;
-    size_t len = size_t(p - value);
-    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
-    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
-    memcpy(dst, value, len);
-    dst += len;
-    on_end_string(dst);
-    return SUCCESS;
-  }
-  return err;
+  return numberparsing::parse_number(value, tape);
 }
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -33627,9 +33522,6 @@ struct tape_writer {
   /** Write a double value to tape. */
   simdjson_inline void append_double(double value) noexcept;
 
-  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
-  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
-
   /**
    * Append a tape entry (an 8-bit type,and 56 bits worth of value).
    */
@@ -33713,18 +33605,6 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
   tape_loc = val | ((uint64_t(char(t))) << 56);
 }
 
-simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
-  // Write to string buffer: [4-byte LE length][digits][null]
-  uint32_t str_len = uint32_t(len);
-  memcpy(string_buf, &str_len, sizeof(uint32_t));
-  memcpy(string_buf + sizeof(uint32_t), src, len);
-  string_buf[sizeof(uint32_t) + len] = 0;
-  // Tape entry: offset into string buffer
-  // The caller must set the offset relative to doc.string_buf base
-  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
-  string_buf += sizeof(uint32_t) + len + 1;
-}
-
 } // namespace stage2
 } // unnamed namespace
 } // namespace ppc64
@@ -34662,23 +34542,7 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
   iter.log_value("number");
-  error_code err = numberparsing::parse_number(value, tape);
-  if (simdjson_unlikely(err == BIGINT_ERROR &&
-      iter.dom_parser._number_as_string)) {
-    // Write big integer to string buffer using the same format as strings.
-    // Scan digits the same way parse_number does (skip optional '-', then digits).
-    const uint8_t *p = value;
-    if (*p == '-') p++;
-    while (numberparsing::is_digit(*p)) p++;
-    size_t len = size_t(p - value);
-    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
-    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
-    memcpy(dst, value, len);
-    dst += len;
-    on_end_string(dst);
-    return SUCCESS;
-  }
-  return err;
+  return numberparsing::parse_number(value, tape);
 }
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -40847,9 +40711,6 @@ struct tape_writer {
   /** Write a double value to tape. */
   simdjson_inline void append_double(double value) noexcept;
 
-  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
-  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
-
   /**
    * Append a tape entry (an 8-bit type,and 56 bits worth of value).
    */
@@ -40933,18 +40794,6 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
   tape_loc = val | ((uint64_t(char(t))) << 56);
 }
 
-simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
-  // Write to string buffer: [4-byte LE length][digits][null]
-  uint32_t str_len = uint32_t(len);
-  memcpy(string_buf, &str_len, sizeof(uint32_t));
-  memcpy(string_buf + sizeof(uint32_t), src, len);
-  string_buf[sizeof(uint32_t) + len] = 0;
-  // Tape entry: offset into string buffer
-  // The caller must set the offset relative to doc.string_buf base
-  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
-  string_buf += sizeof(uint32_t) + len + 1;
-}
-
 } // namespace stage2
 } // unnamed namespace
 } // namespace westmere
@@ -41882,23 +41731,7 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
   iter.log_value("number");
-  error_code err = numberparsing::parse_number(value, tape);
-  if (simdjson_unlikely(err == BIGINT_ERROR &&
-      iter.dom_parser._number_as_string)) {
-    // Write big integer to string buffer using the same format as strings.
-    // Scan digits the same way parse_number does (skip optional '-', then digits).
-    const uint8_t *p = value;
-    if (*p == '-') p++;
-    while (numberparsing::is_digit(*p)) p++;
-    size_t len = size_t(p - value);
-    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
-    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
-    memcpy(dst, value, len);
-    dst += len;
-    on_end_string(dst);
-    return SUCCESS;
-  }
-  return err;
+  return numberparsing::parse_number(value, tape);
 }
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -47098,9 +46931,6 @@ struct tape_writer {
   /** Write a double value to tape. */
   simdjson_inline void append_double(double value) noexcept;
 
-  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
-  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
-
   /**
    * Append a tape entry (an 8-bit type,and 56 bits worth of value).
    */
@@ -47184,18 +47014,6 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
   tape_loc = val | ((uint64_t(char(t))) << 56);
 }
 
-simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
-  // Write to string buffer: [4-byte LE length][digits][null]
-  uint32_t str_len = uint32_t(len);
-  memcpy(string_buf, &str_len, sizeof(uint32_t));
-  memcpy(string_buf + sizeof(uint32_t), src, len);
-  string_buf[sizeof(uint32_t) + len] = 0;
-  // Tape entry: offset into string buffer
-  // The caller must set the offset relative to doc.string_buf base
-  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
-  string_buf += sizeof(uint32_t) + len + 1;
-}
-
 } // namespace stage2
 } // unnamed namespace
 } // namespace lasx
@@ -48133,23 +47951,7 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
   iter.log_value("number");
-  error_code err = numberparsing::parse_number(value, tape);
-  if (simdjson_unlikely(err == BIGINT_ERROR &&
-      iter.dom_parser._number_as_string)) {
-    // Write big integer to string buffer using the same format as strings.
-    // Scan digits the same way parse_number does (skip optional '-', then digits).
-    const uint8_t *p = value;
-    if (*p == '-') p++;
-    while (numberparsing::is_digit(*p)) p++;
-    size_t len = size_t(p - value);
-    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
-    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
-    memcpy(dst, value, len);
-    dst += len;
-    on_end_string(dst);
-    return SUCCESS;
-  }
-  return err;
+  return numberparsing::parse_number(value, tape);
 }
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -53253,9 +53055,6 @@ struct tape_writer {
   /** Write a double value to tape. */
   simdjson_inline void append_double(double value) noexcept;
 
-  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
-  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
-
   /**
    * Append a tape entry (an 8-bit type,and 56 bits worth of value).
    */
@@ -53339,18 +53138,6 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
   tape_loc = val | ((uint64_t(char(t))) << 56);
 }
 
-simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
-  // Write to string buffer: [4-byte LE length][digits][null]
-  uint32_t str_len = uint32_t(len);
-  memcpy(string_buf, &str_len, sizeof(uint32_t));
-  memcpy(string_buf + sizeof(uint32_t), src, len);
-  string_buf[sizeof(uint32_t) + len] = 0;
-  // Tape entry: offset into string buffer
-  // The caller must set the offset relative to doc.string_buf base
-  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
-  string_buf += sizeof(uint32_t) + len + 1;
-}
-
 } // namespace stage2
 } // unnamed namespace
 } // namespace lsx
@@ -54288,23 +54075,7 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
   iter.log_value("number");
-  error_code err = numberparsing::parse_number(value, tape);
-  if (simdjson_unlikely(err == BIGINT_ERROR &&
-      iter.dom_parser._number_as_string)) {
-    // Write big integer to string buffer using the same format as strings.
-    // Scan digits the same way parse_number does (skip optional '-', then digits).
-    const uint8_t *p = value;
-    if (*p == '-') p++;
-    while (numberparsing::is_digit(*p)) p++;
-    size_t len = size_t(p - value);
-    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
-    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
-    memcpy(dst, value, len);
-    dst += len;
-    on_end_string(dst);
-    return SUCCESS;
-  }
-  return err;
+  return numberparsing::parse_number(value, tape);
 }
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -59827,9 +59598,6 @@ struct tape_writer {
   /** Write a double value to tape. */
   simdjson_inline void append_double(double value) noexcept;
 
-  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
-  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
-
   /**
    * Append a tape entry (an 8-bit type,and 56 bits worth of value).
    */
@@ -59913,18 +59681,6 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
   tape_loc = val | ((uint64_t(char(t))) << 56);
 }
 
-simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
-  // Write to string buffer: [4-byte LE length][digits][null]
-  uint32_t str_len = uint32_t(len);
-  memcpy(string_buf, &str_len, sizeof(uint32_t));
-  memcpy(string_buf + sizeof(uint32_t), src, len);
-  string_buf[sizeof(uint32_t) + len] = 0;
-  // Tape entry: offset into string buffer
-  // The caller must set the offset relative to doc.string_buf base
-  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
-  string_buf += sizeof(uint32_t) + len + 1;
-}
-
 } // namespace stage2
 } // unnamed namespace
 } // namespace rvv_vls
@@ -60862,23 +60618,7 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
   iter.log_value("number");
-  error_code err = numberparsing::parse_number(value, tape);
-  if (simdjson_unlikely(err == BIGINT_ERROR &&
-      iter.dom_parser._number_as_string)) {
-    // Write big integer to string buffer using the same format as strings.
-    // Scan digits the same way parse_number does (skip optional '-', then digits).
-    const uint8_t *p = value;
-    if (*p == '-') p++;
-    while (numberparsing::is_digit(*p)) p++;
-    size_t len = size_t(p - value);
-    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
-    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
-    memcpy(dst, value, len);
-    dst += len;
-    on_end_string(dst);
-    return SUCCESS;
-  }
-  return err;
+  return numberparsing::parse_number(value, tape);
 }
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -64449,9 +64189,6 @@ struct tape_writer {
   /** Write a double value to tape. */
   simdjson_inline void append_double(double value) noexcept;
 
-  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
-  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
-
   /**
    * Append a tape entry (an 8-bit type,and 56 bits worth of value).
    */
@@ -64535,18 +64272,6 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
   tape_loc = val | ((uint64_t(char(t))) << 56);
 }
 
-simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
-  // Write to string buffer: [4-byte LE length][digits][null]
-  uint32_t str_len = uint32_t(len);
-  memcpy(string_buf, &str_len, sizeof(uint32_t));
-  memcpy(string_buf + sizeof(uint32_t), src, len);
-  string_buf[sizeof(uint32_t) + len] = 0;
-  // Tape entry: offset into string buffer
-  // The caller must set the offset relative to doc.string_buf base
-  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
-  string_buf += sizeof(uint32_t) + len + 1;
-}
-
 } // namespace stage2
 } // unnamed namespace
 } // namespace fallback
@@ -64730,23 +64455,7 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
   iter.log_value("number");
-  error_code err = numberparsing::parse_number(value, tape);
-  if (simdjson_unlikely(err == BIGINT_ERROR &&
-      iter.dom_parser._number_as_string)) {
-    // Write big integer to string buffer using the same format as strings.
-    // Scan digits the same way parse_number does (skip optional '-', then digits).
-    const uint8_t *p = value;
-    if (*p == '-') p++;
-    while (numberparsing::is_digit(*p)) p++;
-    size_t len = size_t(p - value);
-    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
-    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
-    memcpy(dst, value, len);
-    dst += len;
-    on_end_string(dst);
-    return SUCCESS;
-  }
-  return err;
+  return numberparsing::parse_number(value, tape);
 }
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {

src/generic/stage2/tape_builder.h

@@ -172,23 +172,7 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
   iter.log_value("number");
-  error_code err = numberparsing::parse_number(value, tape);
-  if (simdjson_unlikely(err == BIGINT_ERROR &&
-      iter.dom_parser._number_as_string)) {
-    // Write big integer to string buffer using the same format as strings.
-    // Scan digits the same way parse_number does (skip optional '-', then digits).
-    const uint8_t *p = value;
-    if (*p == '-') p++;
-    while (numberparsing::is_digit(*p)) p++;
-    size_t len = size_t(p - value);
-    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
-    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
-    memcpy(dst, value, len);
-    dst += len;
-    on_end_string(dst);
-    return SUCCESS;
-  }
-  return err;
+  return numberparsing::parse_number(value, tape);
 }
 
 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {

src/generic/stage2/tape_writer.h

@@ -26,9 +26,6 @@ struct tape_writer {
   /** Write a double value to tape. */
   simdjson_inline void append_double(double value) noexcept;
 
-  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
-  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
-
   /**
    * Append a tape entry (an 8-bit type,and 56 bits worth of value).
    */
@@ -112,18 +109,6 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
   tape_loc = val | ((uint64_t(char(t))) << 56);
 }
 
-simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
-  // Write to string buffer: [4-byte LE length][digits][null]
-  uint32_t str_len = uint32_t(len);
-  memcpy(string_buf, &str_len, sizeof(uint32_t));
-  memcpy(string_buf + sizeof(uint32_t), src, len);
-  string_buf[sizeof(uint32_t) + len] = 0;
-  // Tape entry: offset into string buffer
-  // The caller must set the offset relative to doc.string_buf base
-  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
-  string_buf += sizeof(uint32_t) + len + 1;
-}
-
 } // namespace stage2
 } // unnamed namespace
 } // namespace SIMDJSON_IMPLEMENTATION

tests/builder/static_reflection_builder_tests.cpp

@@ -6,40 +6,40 @@
 
 using namespace simdjson;
 struct Car {
-  std::string make{};
-  std::string model{};
-  int64_t year{};
-  std::vector<double> tire_pressure{};
+  std::string make;
+  std::string model;
+  int64_t year;
+  std::vector<double> tire_pressure;
 };
 
 struct kid {
-  int age{};
-  std::string name{};
-  std::vector<std::string> toys{};
+  int age;
+  std::string name;
+  std::vector<std::string> toys;
   bool operator<=> (const kid&) const = default;
 };
 
 struct Z {
-  int x{};
+  int x;
   bool operator<=> (const Z&) const = default;
 };
 
 struct Y {
-  int g{};
-  std::string h{};
-  std::vector<int> i{};
-  Z z{};
+  int g;
+  std::string h;
+  std::vector<int> i;
+  Z z;
   bool operator<=> (const Y&) const = default;
 };
 
 struct X {
-  char a{};
-  int b{};
-  int c{};
-  std::string d{};
-  std::vector<int> e{};
-  std::vector<std::string> f{};
-  Y y{};
+  char a;
+  int b;
+  int c;
+  std::string d;
+  std::vector<int> e;
+  std::vector<std::string> f;
+  Y y;
   bool operator<=> (const X&) const = default;
 };
 

tests/builder/static_reflection_comprehensive_tests.cpp

@@ -16,8 +16,8 @@ namespace builder_tests {
 #if SIMDJSON_STATIC_REFLECTION
   // Custom type for testing tag_invoke with extract_into
   struct Price {
-    double amount{};
-    std::string currency{};
+    double amount;
+    std::string currency;
 
     // Custom deserializer that applies currency conversion
     friend error_code tag_invoke(deserialize_tag,
@@ -46,37 +46,17 @@ namespace builder_tests {
       return SUCCESS;
     }
   };
-  struct Car {
-    std::string make{};
-    std::string model{};
-    int year{};
-    double price{};
-    bool electric{};
-  };
-  struct CarOpt {
-    std::string make;
-    std::string model;
-    int year;
-    double price;
-    std::optional<std::string> color;
-  };
-  struct CarColor {
-    std::string make;
-    std::string model;
-    int year;
-    double price;
-    std::string color;
-  };
+
   struct Product {
-    std::string name{};
-    Price price{};  // Custom deserializable type
-    int stock{};
+    std::string name;
+    Price price;  // Custom deserializable type
+    int stock;
   };
 
   // Another custom type for testing
   struct Dimensions {
-    double value{};
-    std::string unit{};
+    double value;
+    std::string unit;
 
     // Custom deserializer that converts to metric
     friend error_code tag_invoke(deserialize_tag,
@@ -109,13 +89,6 @@ namespace builder_tests {
     Dimensions weight;
     Dimensions length;
   };
-
-  struct Person {
-    std::string name;
-    int age;
-    std::optional<std::string> email;
-    std::optional<std::string> phone;
-  };
 #endif
 
   bool test_primitive_types() {
@@ -159,8 +132,8 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct StringTypes {
-      std::string string_val{};
-      std::string_view string_view_val{};
+      std::string string_val;
+      std::string_view string_view_val;
     };
 
     StringTypes test{"hello world", "test_view"};
@@ -186,10 +159,10 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct OptionalTypes {
-      std::optional<int> opt_int_with_value{};
-      std::optional<std::string> opt_string_with_value{};
-      std::optional<int> opt_int_null{};
-      std::optional<std::string> opt_string_null{};
+      std::optional<int> opt_int_with_value;
+      std::optional<std::string> opt_string_with_value;
+      std::optional<int> opt_int_null;
+      std::optional<std::string> opt_string_null;
     };
 
     OptionalTypes test;
@@ -227,11 +200,11 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct SmartPointerTypes {
-      std::unique_ptr<int> unique_int_with_value{};
-      std::shared_ptr<std::string> shared_string_with_value{};
-      std::unique_ptr<bool> unique_bool_with_value{};
-      std::unique_ptr<int> unique_int_null{};
-      std::shared_ptr<std::string> shared_string_null{};
+      std::unique_ptr<int> unique_int_with_value;
+      std::shared_ptr<std::string> shared_string_with_value;
+      std::unique_ptr<bool> unique_bool_with_value;
+      std::unique_ptr<int> unique_int_null;
+      std::shared_ptr<std::string> shared_string_null;
     };
 
     SmartPointerTypes test;
@@ -272,9 +245,9 @@ namespace builder_tests {
 #if SIMDJSON_STATIC_REFLECTION
     // Test basic container types
     struct ContainerTypes {
-      std::vector<int> int_vector{};
-      std::set<std::string> string_set{};
-      std::map<std::string, int> string_map{};
+      std::vector<int> int_vector;
+      std::set<std::string> string_set;
+      std::map<std::string, int> string_map;
     };
 
     ContainerTypes test;
@@ -305,8 +278,8 @@ namespace builder_tests {
 
     // Test std::list with iterator-based serialization
     struct ListContainer {
-      std::list<int> int_list{};
-      std::list<std::string> string_list{};
+      std::list<int> int_list;
+      std::list<std::string> string_list;
     };
 
     ListContainer list_test;
@@ -346,7 +319,13 @@ namespace builder_tests {
   bool test_extract_into() {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
-
+    struct Car {
+      std::string make;
+      std::string model;
+      int year;
+      double price;
+      std::optional<std::string> color;
+    };
 
     ondemand::parser parser;
 
@@ -362,7 +341,7 @@ namespace builder_tests {
         "transmission": "Automatic"
       })"_padded;
 
-      CarOpt car{};
+      Car car{};
       ondemand::document doc;
       ASSERT_SUCCESS( parser.iterate(padded).get(doc) );
 
@@ -398,7 +377,7 @@ namespace builder_tests {
         "color": "Red"
       })"_padded;
 
-      CarOpt car{};
+      Car car{};
       ondemand::document doc;
       ASSERT_SUCCESS(parser.iterate(padded).get(doc));
 
@@ -423,7 +402,7 @@ namespace builder_tests {
         "price": 35999.99
       })"_padded;
 
-      CarOpt car{};
+      Car car{};
       ondemand::document doc;
       ASSERT_SUCCESS(parser.iterate(padded).get(doc));
 
@@ -516,6 +495,13 @@ namespace builder_tests {
 #if SIMDJSON_STATIC_REFLECTION
     // Test 1: Extract specific fields from Car struct
     {
+      struct Car {
+        std::string make;
+        std::string model;
+        int year;
+        double price;
+        bool electric;
+      };
 
       Car car{"Tesla", "Model 3", 2023, 42000.0, true};
 
@@ -547,7 +533,13 @@ namespace builder_tests {
 
     // Test 2: Extract different field combination
     {
-
+      struct Car {
+        std::string make;
+        std::string model;
+        int year;
+        double price;
+        bool electric;
+      };
 
       Car car{"Ford", "F-150", 2024, 55000.0, false};
 
@@ -574,6 +566,13 @@ namespace builder_tests {
 
     // Test 3: Extract from struct with optional fields
     {
+      struct Person {
+        std::string name;
+        int age;
+        std::optional<std::string> email;
+        std::optional<std::string> phone;
+      };
+
       Person person{"John Doe", 30, "john@example.com", std::nullopt};
 
       // Extract name and email
@@ -595,6 +594,13 @@ namespace builder_tests {
 
     // Test 4: Extract with optional that has value
     {
+      struct Person {
+        std::string name;
+        int age;
+        std::optional<std::string> email;
+        std::optional<std::string> phone;
+      };
+
       Person person{"Jane Smith", 25, "jane@example.com", "555-1234"};
 
       // Extract name, age, and phone
@@ -623,21 +629,21 @@ namespace builder_tests {
 
     // Test 5: Round-trip test - serialize with extract_from, deserialize with extract_into
     {
-      struct MyProduct {
-        std::string id{};
-        std::string name{};
-        double price{};
-        int stock{};
+      struct Product {
+        std::string id;
+        std::string name;
+        double price;
+        int stock;
       };
 
-      MyProduct original{"P123", "Widget", 19.99, 100};
+      Product original{"P123", "Widget", 19.99, 100};
 
       // Extract specific fields to JSON
       std::string json;
       ASSERT_SUCCESS((extract_from<"id", "name", "price">(original).get(json)));
 
       // Parse and extract back
-      MyProduct restored{"", "", 0.0, 0};
+      Product restored{"", "", 0.0, 0};
       auto padded = pad(json);
       ondemand::parser parser;
       auto doc = parser.iterate(padded);

tests/builder/static_reflection_custom_tests.cpp

@@ -11,10 +11,10 @@ using namespace simdjson;
 // Suppose that we want to serialize/deserialize Car using
 // strings for the year
 struct Car {
-  std::string make{};
-  std::string model{};
-  int64_t year{};
-  std::vector<float> tire_pressure{};
+  std::string make;
+  std::string model;
+  int64_t year;
+  std::vector<float> tire_pressure;
 };
 
 

tests/builder/static_reflection_edge_cases_tests.cpp

@@ -14,11 +14,11 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct EmptyValues {
-      std::string empty_string{};
-      std::vector<int> empty_vector{};
-      std::optional<int> null_optional{};
-      std::unique_ptr<int> null_unique_ptr{};
-      std::shared_ptr<std::string> null_shared_ptr{};
+      std::string empty_string;
+      std::vector<int> empty_vector;
+      std::optional<int> null_optional;
+      std::unique_ptr<int> null_unique_ptr;
+      std::shared_ptr<std::string> null_shared_ptr;
     };
 
     EmptyValues test;
@@ -56,18 +56,18 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct SpecialChars {
-      std::string quotes{};
-      std::string backslashes{};
-      std::string newlines{};
-      std::string unicode{};
-      char null_char{};
+      std::string quotes;
+      std::string backslashes;
+      std::string newlines;
+      std::string unicode;
+      char null_char;
     };
 
     SpecialChars test;
     test.quotes = "He said \"Hello\"";
     test.backslashes = "Path\\to\\file";
     test.newlines = "Line1\nLine2\tTabbed";
-    test.unicode = "Caf\xc3\xa9 r\xc3\xa9sum\xc3\xa9";
+    test.unicode = "Café résumé";
     test.null_char = '\0';
 
     std::string json;
@@ -82,10 +82,10 @@ namespace builder_tests {
 
     // Test round-trip (excluding null char which has special handling)
     struct SpecialCharsNoNull {
-      std::string quotes{};
-      std::string backslashes{};
-      std::string newlines{};
-      std::string unicode{};
+      std::string quotes;
+      std::string backslashes;
+      std::string newlines;
+      std::string unicode;
     };
 
     SpecialCharsNoNull test_no_null;
@@ -157,15 +157,15 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct Inner {
-      int value{};
-      std::string name{};
+      int value;
+      std::string name;
     };
 
     struct Outer {
-      Inner inner_obj{};
-      std::vector<Inner> inner_vector{};
-      std::optional<Inner> optional_inner{};
-      std::unique_ptr<Inner> unique_inner{};
+      Inner inner_obj;
+      std::vector<Inner> inner_vector;
+      std::optional<Inner> optional_inner;
+      std::unique_ptr<Inner> unique_inner;
     };
 
     Outer test;
@@ -213,4 +213,4 @@ namespace builder_tests {
 
 int main(int argc, char *argv[]) {
   return test_main(argc, argv, builder_tests::run);
-}
+}

tests/builder/static_reflection_enum_tests.cpp

@@ -51,8 +51,8 @@ namespace builder_tests {
     };
 
     struct StatusStruct {
-      Status status{};
-      std::string name{};
+      Status status;
+      std::string name;
     };
 
     // Test deserialization of different enum values with string representation
@@ -104,9 +104,9 @@ namespace builder_tests {
     };
 
     struct Task {
-      Priority priority{};
-      std::string description{};
-      int id{};
+      Priority priority;
+      std::string description;
+      int id;
     };
 
     Task original{Priority::High, "Important task", 123};
@@ -144,8 +144,8 @@ namespace builder_tests {
     };
 
     struct Response {
-      ErrorCode error{};
-      std::string message{};
+      ErrorCode error;
+      std::string message;
     };
 
     Response test{ErrorCode::NotFound, "Resource not found"};

tests/builder/static_reflection_fractured_json_tests.cpp

@@ -8,26 +8,26 @@ using namespace simdjson;
 
 // Test structures for FracturedJson builder integration
 struct SimpleUser {
-  int id{};
-  std::string name{};
-  bool active{};
+  int id;
+  std::string name;
+  bool active;
 };
 
 struct UserWithEmail {
-  int id{};
-  std::string name{};
-  std::string email{};
-  bool active{};
+  int id;
+  std::string name;
+  std::string email;
+  bool active;
 };
 
 struct NestedData {
-  std::string title{};
-  std::vector<SimpleUser> users{};
-  int count{};
+  std::string title;
+  std::vector<SimpleUser> users;
+  int count;
 };
 
 struct TableTestData {
-  std::vector<SimpleUser> records{};
+  std::vector<SimpleUser> records;
 };
 
 namespace fractured_json_builder_tests {

tests/compile_time/compile_time_json_tests.cpp

@@ -666,27 +666,27 @@ bool test_array_of_objects_with_concept() {
 /**
  * Test: #embed support for external JSON files (C++26)
  */
-bool test_embed_example_config_json() {
+bool test_embed_twitter_json() {
     TEST_START();
 
     // C++26 #embed allows embedding files directly into the binary at compile time
     // This creates a const char array with the file contents plus null terminator
-    constexpr const unsigned char example_config_json[] = {
-        #embed "../../jsonexamples/example_config.json"
+    constexpr const char twitter_json[] = {
+        #embed TWITTER_JSON
         , 0
     };
 
     // Parse the embedded JSON at compile time
-    constexpr auto parsed_example_config = simdjson::compile_time::parse_json<example_config_json>();
+    constexpr auto parsed_twitter = simdjson::compile_time::parse_json<twitter_json>();
 
-    // Verify the structure - example_config.json should have an "app_name" field
-    static_assert(std::string_view(parsed_example_config.app_name) == "MyApp");
+    // Verify the structure - twitter.json should have a "statuses" array
+    static_assert(parsed_twitter.statuses.size() > 0);
 
     // Runtime verification
-    ASSERT_TRUE(std::string_view(parsed_example_config.app_name) == "MyApp");
+    ASSERT_TRUE(parsed_twitter.statuses.size() > 0);
 
-    std::cout << "Successfully parsed embedded example_config.json with "
-              << parsed_example_config.app_name << " as app_name" << std::endl;
+    std::cout << "Successfully parsed embedded twitter.json with "
+              << parsed_twitter.statuses.size() << " statuses" << std::endl;
 
     TEST_SUCCEED();
 }
@@ -718,10 +718,11 @@ bool run() {
            test_top_level_array_example() &&
            test_array_of_objects_with_concept()
 #ifdef TEST_EMBED_SUPPORTED
-           && test_embed_example_config_json()
+           && test_embed_twitter_json()
 #endif
 ;
 }
+
 } // namespace compile_time_json_tests
 
 int main(int argc, char *argv[]) {

tests/dom/CMakeLists.txt

@@ -11,7 +11,6 @@ add_cpp_test(document_tests             LABELS dom acceptance per_implementation
 add_cpp_test(errortests                 LABELS dom acceptance per_implementation)
 add_cpp_test(extracting_values_example  LABELS dom acceptance per_implementation)
 add_cpp_test(integer_tests              LABELS dom acceptance per_implementation)
-add_cpp_test(big_integer_tests          LABELS dom acceptance per_implementation)
 add_cpp_test(jsoncheck                  LABELS dom acceptance per_implementation)
 add_cpp_test(json_path_tests            LABELS dom acceptance per_implementation)
 add_cpp_test(minefieldcheck             LABELS dom acceptance per_implementation)

tests/dom/big_integer_tests.cpp

@@ -1,151 +0,0 @@
-#include "simdjson.h"
-#include "test_macros.h"
-#include <sstream>
-
-using namespace simdjson;
-
-namespace big_integer_tests {
-
-  bool option_off_by_default() {
-    TEST_START();
-    dom::parser parser;
-    ASSERT_EQUAL(parser.number_as_string(), false);
-    TEST_SUCCEED();
-  }
-
-  bool default_returns_bigint_error() {
-    TEST_START();
-    dom::parser parser;
-    auto result = parser.parse(R"({"val":123456789012345678901})"_padded);
-    ASSERT_EQUAL(result.error(), BIGINT_ERROR);
-    TEST_SUCCEED();
-  }
-
-  bool opt_in_parses_big_integer() {
-    TEST_START();
-    dom::parser parser;
-    parser.number_as_string(true);
-    dom::element doc;
-    ASSERT_SUCCESS(parser.parse(R"({"val":123456789012345678901})"_padded).get(doc));
-    dom::element val;
-    ASSERT_SUCCESS(doc["val"].get(val));
-    ASSERT_EQUAL(val.type(), dom::element_type::BIGINT);
-    ASSERT_TRUE(val.is_bigint());
-    std::string_view digits;
-    ASSERT_SUCCESS(val.get_bigint().get(digits));
-    ASSERT_EQUAL(digits, "123456789012345678901");
-    // Verify streaming works (same pattern as readme_examples)
-    std::ostringstream os;
-    os << val.get_bigint().value_unsafe();
-    ASSERT_EQUAL(os.str(), "123456789012345678901");
-    TEST_SUCCEED();
-  }
-
-  bool negative_big_integer() {
-    TEST_START();
-    dom::parser parser;
-    parser.number_as_string(true);
-    dom::element doc;
-    ASSERT_SUCCESS(parser.parse(R"({"val":-12345678901234567890})"_padded).get(doc));
-    dom::element val;
-    ASSERT_SUCCESS(doc["val"].get(val));
-    ASSERT_EQUAL(val.type(), dom::element_type::BIGINT);
-    std::string_view digits;
-    ASSERT_SUCCESS(val.get_bigint().get(digits));
-    ASSERT_EQUAL(digits, "-12345678901234567890");
-    TEST_SUCCEED();
-  }
-
-  bool big_integer_in_array() {
-    TEST_START();
-    dom::parser parser;
-    parser.number_as_string(true);
-    dom::element doc;
-    ASSERT_SUCCESS(parser.parse(R"([1, 123456789012345678901, 3])"_padded).get(doc));
-    dom::array arr;
-    ASSERT_SUCCESS(doc.get_array().get(arr));
-    size_t count = 0;
-    for (auto elem : arr) { (void)elem; count++; }
-    ASSERT_EQUAL(count, 3);
-    TEST_SUCCEED();
-  }
-
-  bool serialization_preserves_digits() {
-    TEST_START();
-    dom::parser parser;
-    parser.number_as_string(true);
-    dom::element doc;
-    ASSERT_SUCCESS(parser.parse(R"({"val":123456789012345678901})"_padded).get(doc));
-    std::string output = simdjson::to_string(doc);
-    // Raw digits should appear
-    ASSERT_TRUE(output.find("123456789012345678901") != std::string::npos);
-    // Must not be quoted - it's a number, not a string
-    ASSERT_EQUAL(output.find("\"123456789012345678901\""), std::string::npos);
-    TEST_SUCCEED();
-  }
-
-  bool normal_numbers_unaffected() {
-    TEST_START();
-    dom::parser parser;
-    parser.number_as_string(true);
-    dom::element doc;
-    ASSERT_SUCCESS(parser.parse(R"({"a":42,"b":-1,"c":3.14,"d":18446744073709551615})"_padded).get(doc));
-    int64_t a;
-    ASSERT_SUCCESS(doc["a"].get_int64().get(a));
-    ASSERT_EQUAL(a, 42);
-    uint64_t d;
-    ASSERT_SUCCESS(doc["d"].get_uint64().get(d));
-    ASSERT_EQUAL(d, 18446744073709551615ULL);
-    TEST_SUCCEED();
-  }
-
-  bool type_checks() {
-    TEST_START();
-    dom::parser parser;
-    parser.number_as_string(true);
-    dom::element doc;
-    ASSERT_SUCCESS(parser.parse(R"({"val":123456789012345678901})"_padded).get(doc));
-    dom::element val;
-    ASSERT_SUCCESS(doc["val"].get(val));
-    // is_bigint should be true
-    ASSERT_TRUE(val.is_bigint());
-    // other type checks should be false
-    ASSERT_FALSE(val.is_int64());
-    ASSERT_FALSE(val.is_uint64());
-    ASSERT_FALSE(val.is_double());
-    ASSERT_FALSE(val.is_string());
-    ASSERT_FALSE(val.is_bool());
-    ASSERT_FALSE(val.is_null());
-    // get_int64/uint64/double should return INCORRECT_TYPE
-    ASSERT_ERROR(val.get_int64(), INCORRECT_TYPE);
-    ASSERT_ERROR(val.get_uint64(), INCORRECT_TYPE);
-    ASSERT_ERROR(val.get_double(), INCORRECT_TYPE);
-    ASSERT_ERROR(val.get_string(), INCORRECT_TYPE);
-    TEST_SUCCEED();
-  }
-
-  bool element_type_output() {
-    TEST_START();
-    std::ostringstream os;
-    os << dom::element_type::BIGINT;
-    ASSERT_EQUAL(os.str(), "bigint");
-    TEST_SUCCEED();
-  }
-
-  bool run() {
-    return option_off_by_default() &&
-           default_returns_bigint_error() &&
-           opt_in_parses_big_integer() &&
-           negative_big_integer() &&
-           big_integer_in_array() &&
-           serialization_preserves_digits() &&
-           normal_numbers_unaffected() &&
-           type_checks() &&
-           element_type_output();
-  }
-
-} // namespace big_integer_tests
-
-int main() {
-  return big_integer_tests::run() ? 0 : 1;
-}

tests/dom/errortests.cpp

@@ -114,20 +114,6 @@ namespace parser_load {
     TEST_SUCCEED();
   }
 
-  bool parser_load_string_view_subpath() {
-    TEST_START();
-    const std::string valid_path(TWITTER_JSON);
-    const std::string backing = valid_path + ".extra";
-    const std::string_view view(backing.data(), valid_path.size());
-    uint64_t count_from_string = 0;
-    uint64_t count_from_view = 0;
-    dom::parser parser;
-    ASSERT_SUCCESS(parser.load(valid_path)["search_metadata"]["count"].get(count_from_string));
-    ASSERT_SUCCESS(parser.load(view)["search_metadata"]["count"].get(count_from_view));
-    ASSERT_EQUAL(count_from_view, count_from_string);
-    TEST_SUCCEED();
-  }
-
   bool parser_load_chain() {
     TEST_START();
     dom::parser parser;
@@ -150,7 +136,6 @@ namespace parser_load {
         && parser_load_nonexistent()
         && parser_load_many_nonexistent()
         && padded_string_load_nonexistent()
-        && parser_load_string_view_subpath()
         && parser_load_chain()
         && parser_load_many_chain()
         && parser_parse_many_documents_error_in_the_middle()

tests/dom/readme_examples.cpp

@@ -273,9 +273,6 @@ namespace treewalk_1 {
       case dom::element_type::NULL_VALUE:
         cout << "null" << endl;
         break;
-      case dom::element_type::BIGINT:
-        cout << element.get_bigint().value_unsafe() << endl;
-        break;
     }
   }
 

tests/fractured_json_tests.cpp

@@ -475,11 +475,11 @@ bool unicode_test() {
   std::cout << "Running " << __func__ << std::endl;
 
   const char* json = R"({
-    "greeting": "Hello, \u4e16\u754c!",
-    "emoji": "\ud83c\udf89\ud83d\ude80\u2728",
-    "arabic": "\u0645\u0631\u062d\u0628\u0627",
-    "russian": "\u041f\u0440\u0438\u0432\u0435\u0442",
-    "mixed": "caf\u00e9 r\u00e9sum\u00e9 na\u00efve"
+    "greeting": "Hello, 世界!",
+    "emoji": "🎉🚀✨",
+    "arabic": "مرحبا",
+    "russian": "Привет",
+    "mixed": "café résumé naïve"
   })";
 
   simdjson::dom::parser parser;

tests/ondemand/ondemand_convert_tests.cpp

@@ -19,7 +19,7 @@ public:
         return date_str;
     }
 private:
-    std::string date_str{};
+    std::string date_str;
 };
 
 
@@ -52,8 +52,8 @@ auto tag_invoke(deserialize_tag, simdjson_value &val, MyDate& date) {
 } // namespace simdjson
 
 struct complicated_weather_data {
-    std::vector<MyDate> time{};
-    std::vector<float> temperature{};
+    std::vector<MyDate> time;
+    std::vector<float> temperature;
 };
 
 
@@ -152,19 +152,19 @@ simdjson::padded_string json_cars =
     TEST_SUCCEED();
   }
   struct Player {
-      std::string username{};
-      int level{};
-      double health{};
+      std::string username;
+      int level;
+      double health;
   };
   struct BadPlayer {
-      int username{};  // Oops, should be string!
-      int level{};
-      double health{};
+      int username;  // Oops, should be string!
+      int level;
+      double health;
   };
   struct OptionalPlayer {
-      std::string username{};
-      std::optional<int> level{};
-      double health{};
+      std::string username;
+      std::optional<int> level;
+      double health;
   };
 #if SIMDJSON_STATIC_REFLECTION
   bool missing_key_player() {

tests/ondemand/ondemand_document_stream_tests.cpp

@@ -884,30 +884,6 @@ namespace document_stream_tests {
         TEST_SUCCEED();
     }
 
-    bool uint32_with_trailing() {
-        TEST_START();
-        auto json = R"( 133 badstuff )"_padded;
-        ondemand::parser parser;
-        ondemand::document_stream doc;
-        ASSERT_SUCCESS(parser.iterate_many(json).get(doc));
-        uint32_t x;
-        ASSERT_SUCCESS((*doc.begin()).get_uint32().get(x));
-        ASSERT_EQUAL(x,133);
-        TEST_SUCCEED();
-    }
-
-    bool int32_with_trailing() {
-        TEST_START();
-        auto json = R"( 133 badstuff )"_padded;
-        ondemand::parser parser;
-        ondemand::document_stream doc;
-        ASSERT_SUCCESS(parser.iterate_many(json).get(doc));
-        int32_t x;
-        ASSERT_SUCCESS((*doc.begin()).get_int32().get(x));
-        ASSERT_EQUAL(x,133);
-        TEST_SUCCEED();
-    }
-
     bool double_with_trailing() {
         TEST_START();
         auto json = R"( 133 badstuff )"_padded;
@@ -955,8 +931,6 @@ namespace document_stream_tests {
             string_with_trailing() &&
             uint64_with_trailing() &&
             int64_with_trailing() &&
-            uint32_with_trailing() &&
-            int32_with_trailing() &&
             bool_with_trailing() &&
             null_with_trailing() &&
             truncated_utf8() &&

tests/ondemand/ondemand_error_tests.cpp

@@ -171,17 +171,6 @@ namespace error_tests {
     TEST_SUCCEED();
   }
 
-  bool parser_set_max_capacity() {
-    TEST_START();
-    ondemand::parser parser;
-    parser.set_max_capacity(1024 * 1024);
-    ASSERT_EQUAL(parser.max_capacity(), size_t(1024 * 1024));
-    auto json = R"({"k":"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"})"_padded;
-    ondemand::document doc;
-    ASSERT_SUCCESS(parser.iterate(json).get(doc));
-    TEST_SUCCEED();
-  }
-
   bool simple_error_example() {
     TEST_START();
     ondemand::parser parser;
@@ -223,11 +212,7 @@ namespace error_tests {
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_object(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
@@ -250,11 +235,7 @@ namespace error_tests {
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_object(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
@@ -276,11 +257,7 @@ namespace error_tests {
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_object(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
@@ -302,11 +279,7 @@ namespace error_tests {
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_object(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
@@ -333,11 +306,7 @@ namespace error_tests {
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_object(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
@@ -360,11 +329,7 @@ namespace error_tests {
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_object(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
@@ -385,11 +350,7 @@ namespace error_tests {
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_object(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
@@ -410,11 +371,7 @@ namespace error_tests {
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_object(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_int32(), INCORRECT_TYPE );
-      ASSERT_ERROR( val.get_uint32(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_int64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_uint64(), INCORRECT_TYPE );
       ASSERT_ERROR( val.get_double(), INCORRECT_TYPE );
@@ -475,7 +432,6 @@ namespace error_tests {
            raw_json_string_error() &&
            empty_document_error() &&
            parser_max_capacity() &&
-           parser_set_max_capacity() &&
            get_fail_then_succeed_bool() &&
            get_fail_then_succeed_null() &&
            simple_error_example() &&

tests/ondemand/ondemand_number_tests.cpp

@@ -545,111 +545,8 @@ namespace number_tests {
     TEST_SUCCEED();
   }
 
-  bool get_int32_values() {
-    TEST_START();
-    ondemand::parser parser;
-    ondemand::document doc;
-    int32_t val;
-    padded_string docdata;
-
-    // Valid int32 values
-    docdata = "0"_padded;
-    ASSERT_SUCCESS(parser.iterate(docdata).get(doc));
-    ASSERT_SUCCESS(doc.get_int32().get(val));
-    ASSERT_EQUAL(val, 0);
-
-    docdata = "42"_padded;
-    ASSERT_SUCCESS(parser.iterate(docdata).get(doc));
-    ASSERT_SUCCESS(doc.get_int32().get(val));
-    ASSERT_EQUAL(val, 42);
-
-    docdata = "-1"_padded;
-    ASSERT_SUCCESS(parser.iterate(docdata).get(doc));
-    ASSERT_SUCCESS(doc.get_int32().get(val));
-    ASSERT_EQUAL(val, -1);
-
-    docdata = "2147483647"_padded; // INT32_MAX
-    ASSERT_SUCCESS(parser.iterate(docdata).get(doc));
-    ASSERT_SUCCESS(doc.get_int32().get(val));
-    ASSERT_EQUAL(val, 2147483647);
-
-    docdata = "-2147483648"_padded; // INT32_MIN
-    ASSERT_SUCCESS(parser.iterate(docdata).get(doc));
-    ASSERT_SUCCESS(doc.get_int32().get(val));
-    ASSERT_EQUAL(val, -2147483648);
-
-    // Out of range
-    docdata = "2147483648"_padded; // INT32_MAX + 1
-    ASSERT_SUCCESS(parser.iterate(docdata).get(doc));
-    ASSERT_ERROR(doc.get_int32(), NUMBER_OUT_OF_RANGE);
-
-    docdata = "-2147483649"_padded; // INT32_MIN - 1
-    ASSERT_SUCCESS(parser.iterate(docdata).get(doc));
-    ASSERT_ERROR(doc.get_int32(), NUMBER_OUT_OF_RANGE);
-
-    docdata = "9999999999"_padded;
-    ASSERT_SUCCESS(parser.iterate(docdata).get(doc));
-    ASSERT_ERROR(doc.get_int32(), NUMBER_OUT_OF_RANGE);
-
-    // Test via value path
-    auto json = R"({"x": 42})"_padded;
-    ASSERT_SUCCESS(parser.iterate(json).get(doc));
-    ASSERT_SUCCESS(doc["x"].get_int32().get(val));
-    ASSERT_EQUAL(val, 42);
-
-    TEST_SUCCEED();
-  }
-
-  bool get_uint32_values() {
-    TEST_START();
-    ondemand::parser parser;
-    ondemand::document doc;
-    uint32_t val;
-    padded_string docdata;
-
-    // Valid uint32 values
-    docdata = "0"_padded;
-    ASSERT_SUCCESS(parser.iterate(docdata).get(doc));
-    ASSERT_SUCCESS(doc.get_uint32().get(val));
-    ASSERT_EQUAL(val, 0u);
-
-    docdata = "42"_padded;
-    ASSERT_SUCCESS(parser.iterate(docdata).get(doc));
-    ASSERT_SUCCESS(doc.get_uint32().get(val));
-    ASSERT_EQUAL(val, 42u);
-
-    docdata = "4294967295"_padded; // UINT32_MAX
-    ASSERT_SUCCESS(parser.iterate(docdata).get(doc));
-    ASSERT_SUCCESS(doc.get_uint32().get(val));
-    ASSERT_EQUAL(val, 4294967295u);
-
-    // Out of range
-    docdata = "4294967296"_padded; // UINT32_MAX + 1
-    ASSERT_SUCCESS(parser.iterate(docdata).get(doc));
-    ASSERT_ERROR(doc.get_uint32(), NUMBER_OUT_OF_RANGE);
-
-    docdata = "9999999999"_padded;
-    ASSERT_SUCCESS(parser.iterate(docdata).get(doc));
-    ASSERT_ERROR(doc.get_uint32(), NUMBER_OUT_OF_RANGE);
-
-    // Negative values should fail (get_uint64 will fail with INCORRECT_TYPE)
-    docdata = "-1"_padded;
-    ASSERT_SUCCESS(parser.iterate(docdata).get(doc));
-    ASSERT_ERROR(doc.get_uint32(), INCORRECT_TYPE);
-
-    // Test via value path
-    auto json = R"({"x": 42})"_padded;
-    ASSERT_SUCCESS(parser.iterate(json).get(doc));
-    ASSERT_SUCCESS(doc["x"].get_uint32().get(val));
-    ASSERT_EQUAL(val, 42u);
-
-    TEST_SUCCEED();
-  }
-
   bool run() {
-    return get_int32_values() &&
-           get_uint32_values() &&
-           minus_zero() &&
+    return minus_zero() &&
            gigantic_big_int() &&
            big_int_not_zero() &&
            negative_big_int() &&

tests/ondemand/ondemand_wrong_type_error_tests.cpp

@@ -15,9 +15,9 @@ namespace wrong_type_error_tests {
     return false; \
   } \
   { \
-    std::string a_json(R"({ "a": )"); a_json += JSON; a_json += " }"; \
+    padded_string a_json(std::string(R"({ "a": )") + JSON + " }"); \
     std::cout << R"(- Subtest: get_)" << (#TYPE) << "() - JSON: " << a_json << std::endl; \
-    if (!test_ondemand_doc(simdjson::pad(a_json), [&](auto doc_result) { \
+    if (!test_ondemand_doc(a_json, [&](auto doc_result) { \
       ASSERT_ERROR( doc_result["a"].get_##TYPE(), (ERROR) ); \
       return true; \
     })) { \