Create simd bitmask builder

2026-06-08 17:27:07 +00:00 · 2024-08-18 14:29:52 -07:00
61 changed files with 690 additions and 1483 deletions
@@ -45,3 +45,11 @@ Diagnostics:
    Suppress:
        - pragma_attribute_no_pop_eof
        - pragma_attribute_stack_mismatch
+---
+# clang 18
+If:
+    PathMatch:
+        - dependencies/.cache/json11/json11.cpp
+CompileFlags:
+    Add:
+        - -Wno-unqualified-std-cast-call
@@ -1,29 +0,0 @@
-name: Ubuntu ppc64le (GCC 11)
-
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - master
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: uraimo/run-on-arch-action@v2
-        name: Test
-        id: runcmd
-        with:
-          arch: aarch64
-          distro: ubuntu_latest
-          githubToken: ${{ github.token }}
-          install: |
-            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 --build build -j=2
-            ctest --output-on-failure --test-dir build
@@ -17,7 +17,7 @@ jobs:
        fuzz-seconds: 600
        dry-run: false
    - name: Upload Crash
-      uses: actions/upload-artifact@v4
+      uses: actions/upload-artifact@v1
      if: failure() && steps.build.outcome == 'success'
      with:
        name: artifacts
@@ -24,7 +24,7 @@ jobs:
             echo "no trailing whitespace found, good!"
          fi
      - name: Archive whitespace patch
-        uses: actions/upload-artifact@v4
+        uses: actions/upload-artifact@v2
        if: always()
        with:
          name: whitespace-patch
@@ -22,7 +22,7 @@ jobs:
          - msystem: "MINGW64"
            install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
            type: Debug
-          - msystem: "MINGW64"
+            - msystem: "MINGW64"
            install: mingw-w64-x86_64-cmake mingw-w64-x86_64-ninja mingw-w64-x86_64-gcc
            type: RelWithDebInfo
    env:
@@ -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 -B build
            cmake --build build -j=2
            ctest --output-on-failure --test-dir build
@@ -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 -B build
            cmake --build build -j=2
            ctest --output-on-failure --test-dir build
@@ -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 -B build
            cmake --build build -j=2
            ctest --output-on-failure --test-dir build
@@ -26,15 +26,15 @@ jobs:
      run: |
        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build
    - name: Build Debug
-      run: cmake --build build --config ${{matrix.build_type}} --verbose
+      run: cmake --build build --config ${{build_type}} --verbose
    - name: Run tests
      run: |
        cd build
-        ctest -C ${{matrix.build_type}}  -LE explicitonly  --output-on-failure
+        ctest -C ${{build_type}}  -LE explicitonly  --output-on-failure
    - name: Install
      run: |
-        cmake --install build --config ${{matrix.build_type}}
+        cmake --install build --config ${{build_type}}
    - name: Test Installation
      run: |
        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
-        cmake --build build_install_test --config ${{matrix.build_type}}
+        cmake --build build_install_test --config ${{build_type}}
@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.14)
 project(
    simdjson
    # The version number is modified by tools/release.py
-    VERSION 3.10.1
+    VERSION 3.10.0
    DESCRIPTION "Parsing gigabytes of JSON per second"
    HOMEPAGE_URL "https://simdjson.org/"
    LANGUAGES CXX C
@@ -23,11 +23,7 @@ string(
 set(SIMDJSON_LIB_VERSION "23.0.0" CACHE STRING "simdjson library version")
 set(SIMDJSON_LIB_SOVERSION "23" CACHE STRING "simdjson library soversion")

-option(SIMDJSON_BUILD_STATIC_LIB "Build simdjson_static library along with simdjson (only makes sense if BUILD_SHARED_LIBS=ON)" OFF)
-if(SIMDJSON_BUILD_STATIC_LIB AND NOT BUILD_SHARED_LIBS)
-  message(WARNING "SIMDJSON_BUILD_STATIC_LIB only makes sense if BUILD_SHARED_LIBS is set to ON")
-  message(WARNING "You might be building and installing a two identical static libraries.")
-endif()
+option(SIMDJSON_BUILD_STATIC_LIB "Build simdjson_static library along with simdjson" OFF)

 option(SIMDJSON_ENABLE_THREADS "Link with thread support" ON)

@@ -210,7 +206,6 @@ if(SIMDJSON_BUILD_STATIC_LIB)
      TARGETS simdjson_static
      EXPORT simdjson_staticTargets
      ARCHIVE COMPONENT simdjson_Development
-      INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
  )
  install(
      EXPORT simdjson_staticTargets
@@ -287,7 +282,6 @@ enable_testing()
 add_custom_target(all_tests)

 add_subdirectory(windows)
-include(cmake/CPM.cmake)
 add_subdirectory(dependencies) ## This needs to be before tools because of cxxopts
 add_subdirectory(tools)  ## This needs to be before tests because of cxxopts

@@ -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         = "3.10.1"
+PROJECT_NUMBER         = "3.10.0"

 # 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
@@ -50,7 +50,7 @@ private:
                                              uint8_t *p) noexcept;
  simdjson_inline void
  write_raw_string(simdjson::ondemand::raw_json_string rjs);
-  inline void recursive_processor(simdjson::ondemand::value&& element);
+  inline void recursive_processor(simdjson::ondemand::value element);
  inline void recursive_processor_ref(simdjson::ondemand::value& element);

  simdjson::ondemand::parser parser;
@@ -90,13 +90,12 @@ simdjson2msgpack::to_msgpack(const simdjson::padded_string &json,
  } else {
    simdjson::ondemand::value val = doc;
 #define SIMDJSON_GCC_COMPILER ((__GNUC__) && !(__clang__) && !(__INTEL_COMPILER))
-#if 1
-//SIMDJSON_GCC_COMPILER
+#if SIMDJSON_GCC_COMPILER
    // the GCC compiler does well with by-value passing.
    // GCC has superior recursive inlining:
    // https://stackoverflow.com/questions/29186186/why-does-gcc-generate-a-faster-program-than-clang-in-this-recursive-fibonacci-co
    // https://godbolt.org/z/TeK4doE51
-    recursive_processor(std::move(val));
+    recursive_processor(val);
 #else
    recursive_processor_ref(val);
 #endif
@@ -141,7 +140,7 @@ void simdjson2msgpack::write_raw_string(
  write_uint32_at(uint32_t(v.size()), location);
 }

-void simdjson2msgpack::recursive_processor(simdjson::ondemand::value&& element) {
+void simdjson2msgpack::recursive_processor(simdjson::ondemand::value element) {
  switch (element.type()) {
  case simdjson::ondemand::json_type::array: {
    uint32_t counter = 0;
@@ -149,7 +148,7 @@ void simdjson2msgpack::recursive_processor(simdjson::ondemand::value&& element)
    uint8_t *location = skip_uint32();
    for (auto child : element.get_array()) {
      counter++;
-      recursive_processor(std::move(child.value()));
+      recursive_processor(child.value());
    }
    write_uint32_at(counter, location);
  } break;
@@ -1,24 +0,0 @@
-# SPDX-License-Identifier: MIT
-#
-# SPDX-FileCopyrightText: Copyright (c) 2019-2023 Lars Melchior and contributors
-
-set(CPM_DOWNLOAD_VERSION 0.40.2)
-set(CPM_HASH_SUM "c8cdc32c03816538ce22781ed72964dc864b2a34a310d3b7104812a5ca2d835d")
-
-if(CPM_SOURCE_CACHE)
-  set(CPM_DOWNLOAD_LOCATION "${CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
-elseif(DEFINED ENV{CPM_SOURCE_CACHE})
-  set(CPM_DOWNLOAD_LOCATION "$ENV{CPM_SOURCE_CACHE}/cpm/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
-else()
-  set(CPM_DOWNLOAD_LOCATION "${CMAKE_BINARY_DIR}/cmake/CPM_${CPM_DOWNLOAD_VERSION}.cmake")
-endif()
-
-# Expand relative path. This is important if the provided path contains a tilde (~)
-get_filename_component(CPM_DOWNLOAD_LOCATION ${CPM_DOWNLOAD_LOCATION} ABSOLUTE)
-
-file(DOWNLOAD
-     https://github.com/cpm-cmake/CPM.cmake/releases/download/v${CPM_DOWNLOAD_VERSION}/CPM.cmake
-     ${CPM_DOWNLOAD_LOCATION} EXPECTED_HASH SHA256=${CPM_HASH_SUM}
-)
-
-include(${CPM_DOWNLOAD_LOCATION})
@@ -1,4 +1,5 @@
 include(CMakeDependentOption)
+include(import.cmake)

 option(SIMDJSON_ALLOW_DOWNLOADS
        "Allow dependencies to be downloaded during configure time"
@@ -10,21 +11,17 @@ cmake_dependent_option(SIMDJSON_GOOGLE_BENCHMARKS "compile the Google Benchmark
        SIMDJSON_ALLOW_DOWNLOADS OFF)

 if(SIMDJSON_GOOGLE_BENCHMARKS)
-  CPMAddPackage(
-        NAME google_benchmarks
-        URL https://github.com/google/benchmark/archive/refs/tags/v1.7.1.zip
-        OPTIONS
-        "BENCHMARK_ENABLE_TESTING OFF"
-        "BENCHMARK_ENABLE_INSTALL OFF"
-        "BENCHMARK_ENABLE_WERROR OFF"
-  )
+  set_off(BENCHMARK_ENABLE_TESTING)
+  set_off(BENCHMARK_ENABLE_INSTALL)
+  set_off(BENCHMARK_ENABLE_WERROR)
+
+  import_dependency(google_benchmarks google/benchmark v1.7.1)
+  add_dependency(google_benchmarks)
 endif()

-CPMAddPackage(
-        NAME simdjson-data
-        URL https://github.com/simdjson/simdjson-data/archive/a5b13babe65c1bba7186b41b43d4cbdc20a5c470.zip
-)
-
+# The bulk of our benchmarking and testing data has been moved simdjson/simdjson-data
+import_dependency(simdjson-data simdjson/simdjson-data a5b13babe65c1bba7186b41b43d4cbdc20a5c470)
+add_dependency(simdjson-data)
 option(SIMDJSON_USE_BOOST_JSON "Try to include BOOST_JSON, this may break your binaries under some systems." OFF)
 # This prevents variables declared with set() from unnecessarily escaping and
 # should not be called more than once
@@ -41,30 +38,20 @@ function(competition_scope_)
 int main() {}
 ]] SIMDJSON_FOUND_STRING_VIEW)
  if(SIMDJSON_FOUND_STRING_VIEW AND SIMDJSON_USE_BOOST_JSON)
-    CPMAddPackage(
-        NAME boostjson
-        URL https://github.com/boostorg/json/archive/ee8d72d8502b409b5561200299cad30ccdb91415.zip
-    )
+    import_dependency(boostjson boostorg/json ee8d72d)
    add_library(boostjson STATIC "${boostjson_SOURCE_DIR}/src/src.cpp")
    target_compile_definitions(boostjson PUBLIC BOOST_JSON_STANDALONE)
    target_include_directories(boostjson SYSTEM PUBLIC
            "${boostjson_SOURCE_DIR}/include")
    target_compile_definitions(boostjson INTERFACE SIMDJSON_COMPETITION_BOOSTJSON)
  endif()
-  CPMAddPackage(
-      NAME cjson
-      URL https://github.com/DaveGamble/cJSON/archive/c69134d01746dcf551dd7724b4edb12f922eb0d1.zip
-      DOWNLOAD_ONLY YES
-  )
+
+  import_dependency(cjson DaveGamble/cJSON c69134d)
  add_library(cjson STATIC "${cjson_SOURCE_DIR}/cJSON.c")
  target_include_directories(cjson SYSTEM PUBLIC "${cjson_SOURCE_DIR}")
  target_compile_definitions(cjson INTERFACE SIMDJSON_COMPETITION_CJSON)

-  CPMAddPackage(
-      NAME fastjson
-      URL https://github.com/mikeando/fastjson/archive/485f994a61a64ac73fa6a40d4d639b99b463563b.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(fastjson mikeando/fastjson 485f994)
  add_library(fastjson STATIC
          "${fastjson_SOURCE_DIR}/src/fastjson.cpp"
          "${fastjson_SOURCE_DIR}/src/fastjson2.cpp"
@@ -73,36 +60,28 @@ int main() {}
          "${fastjson_SOURCE_DIR}/include")
  target_compile_definitions(fastjson INTERFACE SIMDJSON_COMPETITION_FASTJSON)

-  CPMAddPackage(
-      NAME gason
-      URL https://github.com/vivkin/gason/archive/7aee524189da1c1ecd19f67981e3d903dae25470.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(gason vivkin/gason 7aee524)
  add_library(gason STATIC "${gason_SOURCE_DIR}/src/gason.cpp")
  target_include_directories(gason SYSTEM PUBLIC "${gason_SOURCE_DIR}/src")
  target_compile_definitions(gason INTERFACE SIMDJSON_COMPETITION_GASON)

-  CPMAddPackage(
-      NAME jsmn
-      URL https://github.com/zserge/jsmn/archive/18e9fe42cbfe21d65076f5c77ae2be379ad1270f.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(jsmn zserge/jsmn 18e9fe4)
  add_library(jsmn STATIC "${jsmn_SOURCE_DIR}/jsmn.c")
  target_include_directories(jsmn SYSTEM PUBLIC "${jsmn_SOURCE_DIR}")
  target_compile_definitions(jsmn INTERFACE SIMDJSON_COMPETITION_JSMN)

-  CPMAddPackage(
-      NAME nlohmann_json
-      URL https://github.com/nlohmann/json/archive/refs/tags/v3.10.5.zip
-  )
+  message(STATUS "Importing json (nlohmann/json@v3.10.5)")
+  set(nlohmann_json_SOURCE_DIR "${dep_root}/json")
+  if(NOT EXISTS "${nlohmann_json_SOURCE_DIR}")
+    file(DOWNLOAD
+            "https://github.com/nlohmann/json/releases/download/v3.10.5/json.hpp"
+            "${nlohmann_json_SOURCE_DIR}/nlohmann/json.hpp")
+  endif()
+  add_library(nlohmann_json INTERFACE)
+  target_include_directories(nlohmann_json SYSTEM INTERFACE "${nlohmann_json_SOURCE_DIR}")
+  target_compile_definitions(nlohmann_json INTERFACE SIMDJSON_COMPETITION_NLOHMANN_JSON)

-  set_property(TARGET nlohmann_json APPEND PROPERTY INTERFACE_COMPILE_DEFINITIONS SIMDJSON_COMPETITION_NLOHMANN_JSON)
-
-  CPMAddPackage(
-      NAME json11
-      URL https://github.com/dropbox/json11/archive/ec4e45219af1d7cde3d58b49ed762376fccf1ace.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(json11 dropbox/json11 ec4e452)
  add_library(json11 STATIC "${json11_SOURCE_DIR}/json11.cpp")
  target_include_directories(json11 SYSTEM PUBLIC "${json11_SOURCE_DIR}")
  target_compile_definitions(json11 INTERFACE SIMDJSON_COMPETITION_JSON11)
@@ -112,11 +91,7 @@ int main() {}
  target_include_directories(jsoncpp SYSTEM PUBLIC "${jsoncpp_SOURCE_DIR}")
  target_compile_definitions(jsoncpp INTERFACE SIMDJSON_COMPETITION_JSONCPP)

-  CPMAddPackage(
-      NAME rapidjson
-      URL https://github.com/Tencent/rapidjson/archive/f54b0e47a08782a6131cc3d60f94d038fa6e0a51.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(rapidjson Tencent/rapidjson f54b0e4)
  add_library(rapidjson INTERFACE)
  target_compile_definitions(rapidjson INTERFACE RAPIDJSON_HAS_STDSTRING)
  include (TestBigEndian)
@@ -135,22 +110,14 @@ int main() {}
    target_compile_definitions(rapidjson INTERFACE SIMDJSON_COMPETITION_RAPIDJSON)
  endif()

-  CPMAddPackage(
-      NAME sajson
-      URL https://github.com/chadaustin/sajson/archive/2dcfd350586375f9910f74821d4f07d67ae455ba.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(sajson chadaustin/sajson 2dcfd35)
  add_library(sajson INTERFACE)
  target_compile_definitions(sajson INTERFACE SAJSON_UNSORTED_OBJECT_KEYS)
  target_include_directories(sajson SYSTEM INTERFACE
          "${sajson_SOURCE_DIR}/include")
  target_compile_definitions(sajson INTERFACE SIMDJSON_COMPETITION_SAJSON)

-  CPMAddPackage(
-      NAME ujson4c
-      URL https://github.com/esnme/ujson4c/archive/e14f3fd5207fe30d1bdea723f260609e69d1abfa.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(ujson4c esnme/ujson4c e14f3fd)
  add_library(ujson4c STATIC
          "${ujson4c_SOURCE_DIR}/src/ujdecode.c"
          "${ujson4c_SOURCE_DIR}/3rdparty/ultrajsondec.c")
@@ -159,11 +126,7 @@ int main() {}
          "${ujson4c_SOURCE_DIR}/3rdparty")
  target_compile_definitions(ujson4c INTERFACE SIMDJSON_COMPETITION_UJSON4C)

-  CPMAddPackage(
-      NAME yyjson
-      URL https://github.com/ibireme/yyjson/archive/c3856514de0a67d7b66939bf3ed491a2d6e61277.zip
-      DOWNLOAD_ONLY YES
-  )
+  import_dependency(yyjson ibireme/yyjson c385651)
  add_library(yyjson STATIC "${yyjson_SOURCE_DIR}/src/yyjson.c")
  target_include_directories(yyjson SYSTEM PUBLIC "${yyjson_SOURCE_DIR}/src")
  target_compile_definitions(yyjson INTERFACE SIMDJSON_COMPETITION_YYJSON)
@@ -188,12 +151,10 @@ cmake_dependent_option(SIMDJSON_CXXOPTS "Download cxxopts (necessary for tools)"
        SIMDJSON_ALLOW_DOWNLOADS OFF)

 if(SIMDJSON_CXXOPTS)
-  CPMAddPackage(
-        NAME cxxopts
-        URL https://github.com/jarro2783/cxxopts/archive/59656709c0c58fcd0ed18b38e02938dbe05284c5.zip
-        OPTIONS
-        "CXXOPTS_BUILD_EXAMPLES OFF"
-        "CXXOPTS_BUILD_TESTS OFF"
-        "CXXOPTS_ENABLE_INSTALL OFF"
-  )
+  set_off(CXXOPTS_BUILD_EXAMPLES)
+  set_off(CXXOPTS_BUILD_TESTS)
+  set_off(CXXOPTS_ENABLE_INSTALL)
+
+  import_dependency(cxxopts jarro2783/cxxopts 5965670)
+  add_dependency(cxxopts)
 endif()
@@ -0,0 +1,48 @@
+set(dep_root "${simdjson_SOURCE_DIR}/dependencies/.cache")
+if(DEFINED ENV{simdjson_DEPENDENCY_CACHE_DIR})
+  set(dep_root "$ENV{simdjson_DEPENDENCY_CACHE_DIR}")
+endif()
+
+function(import_dependency NAME GITHUB_REPO COMMIT)
+  message(STATUS "Importing ${NAME} (${GITHUB_REPO}@${COMMIT})")
+  set(target "${dep_root}/${NAME}")
+
+  # If the folder exists in the cache, then we assume that everything is as
+  # should be and do nothing
+  if(EXISTS "${target}")
+    set("${NAME}_SOURCE_DIR" "${target}" PARENT_SCOPE)
+    return()
+  endif()
+
+  set(zip_url "https://github.com/${GITHUB_REPO}/archive/${COMMIT}.zip")
+  set(archive "${dep_root}/archive.zip")
+  set(dest "${dep_root}/_extract")
+
+  file(DOWNLOAD "${zip_url}" "${archive}")
+  file(MAKE_DIRECTORY "${dest}")
+  execute_process(
+          WORKING_DIRECTORY "${dest}"
+          COMMAND "${CMAKE_COMMAND}" -E tar xf "${archive}")
+  file(REMOVE "${archive}")
+
+  # GitHub archives only ever have one folder component at the root, so this
+  # will always match that single folder
+  file(GLOB dir LIST_DIRECTORIES YES "${dest}/*")
+
+  file(RENAME "${dir}" "${target}")
+
+  set("${NAME}_SOURCE_DIR" "${target}" PARENT_SCOPE)
+endfunction()
+
+# Delegates to the dependency
+macro(add_dependency NAME)
+  if(NOT DEFINED "${NAME}_SOURCE_DIR")
+    message(FATAL_ERROR "Missing ${NAME}_SOURCE_DIR variable")
+  endif()
+
+  add_subdirectory("${${NAME}_SOURCE_DIR}" "${PROJECT_BINARY_DIR}/_deps/${NAME}" EXCLUDE_FROM_ALL)
+endmacro()
+
+function(set_off NAME)
+  set("${NAME}" OFF CACHE INTERNAL "")
+endfunction()
@@ -247,7 +247,7 @@ documents.
 For code safety, you should keep (1) the `parser` instance, (2) the input string and (3) the document instance alive throughout your parsing. Additionally, you should follow the following rules:

 - A `parser` may have at most one document open at a time, since it holds allocated memory used for the parsing.
- By design, you should only have one `document` instance per JSON document. Thus, if you must pass a document instance to a function, you should avoid passing it by value: choose to pass it by reference instance to avoid the copy. In any case, the `document` class does not have a copy constructor.
+- By design, you should only have one `document` instance per JSON document. Thus, if you must pass a document instance to a function, you should avoid passing it by value: choose to pass it by reference instance to avoid the copy. (We also provide a `document_reference` class if you need to pass by value.)

 During the `iterate` call, the original JSON text is never modified--only read. After you are done
 with the document, the source (whether file or string) can be safely discarded.
@@ -1224,11 +1224,9 @@ be represented as `value` instances. You can check that a document is a scalar w
 JSONPath
 ------------

-The simdjson library supports a subset of [JSONPath](https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
+The simdjson library now supports a subset of [JSONPath](https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.

-This implementation relies on `at_path()` converting its argument to JSON Pointer and then calling `at_pointer`, which makes use of
-[`rewind`](#rewind) to reset the parser at the beginning of the document. Hence, it invalidates all previously parsed values, objects
- and arrays: make sure to consume the values between each call to `at_path`.
+This implementation relies on `at_path()` converting its argument to JSON Pointer and then calling `at_pointer`, which makes use of [`rewind`](#rewind) to reset the parser at the beginning of the document. Hence, it invalidates all previously parsed values, objects and arrays: make sure to consume the values between each call to `at_path`.

 Consider the following example:

@@ -1269,18 +1267,6 @@ doc.at_path(".\\u00E9") == 123; // true
 doc.at_path((const char*)u8".\u00E9") // returns an error (NO_SUCH_FIELD)
 ```

-
-We also support the `$` prefix. When you start a JSONPath expression with $, you are indicating that the path starts from the root of the JSON document. E.g.,
-
-```c++
-auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
-ondemand::parser parser;
-ondemand::document doc = parser.iterate(json);
-ondemand::object obj = doc.get_object();
-int64_t x = obj.at_path("$.c.foo.a[1]"); // 20
-x = obj.at_path("$.d.foo2.a.2"); // 30
-```
-
 Error handling
 --------------

@@ -2687,7 +2673,6 @@ Performance tips
 	std::string_view year = data["year"];
 	std::string_view rating = data["rating"];
  ```
- You will get better performance if you seek the keys in the order in which they appear in the document. So if processing `{"a":1, "b":2, "c":3}`, do `value1 = data["a"]; value2 = data["b"]; value3 data["c"];` and not `value2 = data["b"]; value1 = data["a"]; value3 data["c"];`. Of course, it is not always possible to know for sure in which order the keys appear.



@@ -8,7 +8,6 @@ An overview of what you need to know to use simdjson, with examples.
 * [Using the Parsed JSON](#using-the-parsed-json)
 * [C++17 Support](#c17-support)
 * [JSON Pointer](#json-pointer)
-* [JSONPath](#jsonpath)
 * [Error Handling](#error-handling)
  * [Error Handling Example](#error-handling-example)
  * [Exceptions](#exceptions)
@@ -258,49 +257,6 @@ for (dom::element car_element : cars) {
 }
 ```

-JSONPath
------------
-
-
-The simdjson library supports a subset of [JSONPath](https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
-
-Consider the following example:
-
-```c++
-auto cars_json = R"( [
-  { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
-] )"_padded;
-dom::parser parser;
-dom::element doc;
-auto error = parser.parse(cars_json).get(doc);
-if(error) { /*won't happen*/ }
-double p;
-error = doc.at_path("[0].tire_pressure[1]").get(p);
-if(error) { /*won't happen*/ }
-cout << p << endl; // Prints 39.9
-```
-
-
-We also support the `$` prefix. When you start a JSONPath expression with $, you are indicating that the path starts from the root of the JSON document. E.g.,
-
-```c++
-auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
-dom::parser parser;
-dom::element doc;
-auto error = parser.parse(json).get(doc);
-if(error) { /*won't happen*/ }
-dom::object obj;
-error = doc.get_object().get(obj);
-if(error) { /*won't happen*/ }
-int64_t x;
-error = obj.at_path("$[3].foo.a[1]").get(x);
-if(error) { /*won't happen*/ }
-if(x != 20) { /*won't happen*/ }
-x = obj.at_path("$.d.foo2.a.2");
-if(error) { /*won't happen*/ }
-```


 Error Handling
@@ -102,12 +102,7 @@ remove almost entirely its cost and replaces it by the overhead of a thread, whi
 cheaper. Ain't that awesome!

 Thread support is only active if thread supported is detected in which case the macro
-SIMDJSON_THREADS_ENABLED is set.  You can also manually pass `SIMDJSON_THREADS_ENABLED=1` flag
-to the library. Otherwise the library runs in single-thread mode.
-
-You should be consistent. If you link against the simdjson library built for multithreading
-(i.e., with `SIMDJSON_THREADS_ENABLED`), then you should build your application with multithreading
-system (setting `SIMDJSON_THREADS_ENABLED=1` and linking against a thread library).
+SIMDJSON_THREADS_ENABLED is set. Otherwise the library runs in  single-thread mode.

 A `document_stream` instance uses at most two threads: there is a main thread and a worker thread.

@@ -103,12 +103,7 @@ cases, remove almost entirely its cost and replaces it by the overhead of a thre
 of magnitude cheaper. Ain't that awesome!

 Thread support is only active if thread supported is detected in which case the macro
-SIMDJSON_THREADS_ENABLED is set.  You can also manually pass `SIMDJSON_THREADS_ENABLED=1` flag
-to the library. Otherwise the library runs in single-thread mode.
-
-You should be consistent. If you link against the simdjson library built for multithreading
-(i.e., with `SIMDJSON_THREADS_ENABLED`), then you should build your application with multithreading
-system (setting `SIMDJSON_THREADS_ENABLED=1` and linking against a thread library).
+SIMDJSON_THREADS_ENABLED is set. Otherwise the library runs in  single-thread mode.

 A `document_stream` instance uses at most two threads: there is a main thread and a worker thread.
 You should expect the main thread to be fully occupied while the worker thread is partially busy
@@ -241,8 +241,8 @@ long page_size() {
 // Returns true if the buffer + len + simdjson::SIMDJSON_PADDING crosses the
 // page boundary.
 bool need_allocation(const char *buf, size_t len) {
-  return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size())
-    + simdjson::SIMDJSON_PADDING > static_cast<uintptr_t>(page_size()));
+  return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size()) <
+          simdjson::SIMDJSON_PADDING);
 }

 simdjson::padded_string_view
@@ -35,12 +35,6 @@ simdjson_inline uint64_t clear_lowest_bit(uint64_t input_num) {
  return input_num & (input_num-1);
 }

-// We sometimes call leading_zeroes on inputs that are zero,
-// but the algorithms do not end up using the returned value.
-// Sadly, sanitizers are not smart enough to figure it out.
-// Applies only when SIMDJSON_PREFER_REVERSE_BITS is defined and true.
-// (See below.)
-SIMDJSON_NO_SANITIZE_UNDEFINED
 /* result might be undefined when input_num is zero */
 simdjson_inline int leading_zeroes(uint64_t input_num) {
 #ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
@@ -51,12 +51,6 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace arm64
 } // namespace simdjson

-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif

 #endif // SIMDJSON_ARM64_NUMBERPARSING_DEFS_H
@@ -412,6 +412,66 @@ namespace {
    }
  };

+#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
+      static const uint8x16_t BITMASK64_BUILDER_MASK = simdjson_make_uint8x16_t(
+        0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
+        0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80
+      );
+#else
+      static const uint8x16_t BITMASK64_BUILDER_MASK = {
+        0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
+        0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80
+      };
+#endif
+
+  template <int N = 0>
+  struct simd_bitmask64_builder;
+
+  template<>
+  struct simd_bitmask64_builder<4> {
+    const uint64_t mask;
+    operator uint64_t() && { return mask; }
+  }; // struct simd_bitmask64_builder<4>
+
+  template<>
+  struct simd_bitmask64_builder<3> {
+    const uint8x16_t sum01;
+    const simd8<bool> val2;
+    simdjson_inline simd_bitmask64_builder<4> next(simd8<bool> val3) {
+      // Add each of the elements next to each other, successively, to stuff each 8 byte mask into one.
+      uint8x16_t sum23 = vpaddq_u8(val2 & BITMASK64_BUILDER_MASK, val3 & BITMASK64_BUILDER_MASK);
+      uint8x16_t sum0123 = vpaddq_u8(sum01, sum23);
+
+      // This algorithm is actually designed to create a 128-bit mask from 8 16-byte simd masks,
+      // but since we only want 64 bits, we add the mask to itself (creating the final mask twice).
+      uint8x16_t sum01230123 = vpaddq_u8(sum0123, sum0123);
+      return { vgetq_lane_u64(vreinterpretq_u64_u8(sum01230123), 0) };
+    }
+  }; // struct simd_bitmask64_builder<3>
+
+  template<>
+  struct simd_bitmask64_builder<2> {
+    const uint8x16_t sum01;
+    simdjson_inline simd_bitmask64_builder<3> next(simd8<bool> val2) {
+      return { sum01, val2 };
+    }
+  }; // struct simd_bitmask64_builder<2>
+
+  template<>
+  struct simd_bitmask64_builder<1> {
+    const simd8<bool> val0;
+    simdjson_inline simd_bitmask64_builder<2> next(simd8<bool> val1) {
+      return { vpaddq_u8(val0 & BITMASK64_BUILDER_MASK, val1 & BITMASK64_BUILDER_MASK) };
+    }
+  }; // struct simd_bitmask64_builder<1>
+
+  template<>
+  struct simd_bitmask64_builder<0> {
+    simdjson_inline simd_bitmask64_builder<1> next(simd8<bool> val) {
+      return { val };
+    }
+  }; // struct simd_bitmask64_builder<0>
+
  template<typename T>
  struct simd8x64 {
    static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
@@ -449,23 +509,11 @@ namespace {
    }

    simdjson_inline uint64_t to_bitmask() const {
-#ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
-      const uint8x16_t bit_mask = simdjson_make_uint8x16_t(
-        0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
-        0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80
-      );
-#else
-      const uint8x16_t bit_mask = {
-        0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,
-        0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80
-      };
-#endif
-      // Add each of the elements next to each other, successively, to stuff each 8 byte mask into one.
-      uint8x16_t sum0 = vpaddq_u8(this->chunks[0] & bit_mask, this->chunks[1] & bit_mask);
-      uint8x16_t sum1 = vpaddq_u8(this->chunks[2] & bit_mask, this->chunks[3] & bit_mask);
-      sum0 = vpaddq_u8(sum0, sum1);
-      sum0 = vpaddq_u8(sum0, sum0);
-      return vgetq_lane_u64(vreinterpretq_u64_u8(sum0), 0);
+      return simd_bitmask64_builder<0>()
+        .next(this->chunks[0])
+        .next(this->chunks[1])
+        .next(this->chunks[2])
+        .next(this->chunks[3]);
    }

    simdjson_inline uint64_t eq(const T m) const {
@@ -7,7 +7,6 @@
 #include "simdjson/dom/array.h"
 #include "simdjson/dom/element.h"
 #include "simdjson/error-inl.h"
-#include "simdjson/jsonpathutil.h"
 #include "simdjson/internal/tape_ref-inl.h"

 #include <limits>
@@ -45,13 +44,6 @@ inline simdjson_result<dom::element> simdjson_result<dom::array>::at_pointer(std
  if (error()) { return error(); }
  return first.at_pointer(json_pointer);
 }
-
- inline simdjson_result<dom::element> simdjson_result<dom::array>::at_path(std::string_view json_path) const noexcept {
-  auto json_pointer = json_path_to_pointer_conversion(json_path);
-  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
-  return at_pointer(json_pointer);
- }
-
 inline simdjson_result<dom::element> simdjson_result<dom::array>::at(size_t index) const noexcept {
  if (error()) { return error(); }
  return first.at(index);
@@ -121,12 +113,6 @@ inline simdjson_result<element> array::at_pointer(std::string_view json_pointer)
  return child;
 }

-inline simdjson_result<element> array::at_path(std::string_view json_path) const noexcept {
-  auto json_pointer = json_path_to_pointer_conversion(json_path);
-  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
-  return at_pointer(json_pointer);
-}
-
 inline simdjson_result<element> array::at(size_t index) const noexcept {
  SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914
  size_t i=0;
@@ -108,21 +108,6 @@ public:
   */
  inline simdjson_result<element> at_pointer(std::string_view json_pointer) const noexcept;

-  /**
-   * Get the value associated with the given JSONPath expression. We only support
-   * JSONPath queries that trivially convertible to JSON Pointer queries: key
-   * names and array indices.
-   *
-   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
-   *
-   * @return The value associated with the given JSONPath expression, or:
-   *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails
-   *         - NO_SUCH_FIELD if a field does not exist in an object
-   *         - INDEX_OUT_OF_BOUNDS if an array index is larger than an array length
-   *         - INCORRECT_TYPE if a non-integer is used to access an array
-  */
-  inline simdjson_result<element> at_path(std::string_view json_path) const noexcept;
-
  /**
   * Get the value at the given index. This function has linear-time complexity and
   * is equivalent to the following:
@@ -167,7 +152,6 @@ public:
  simdjson_inline simdjson_result(error_code error) noexcept; ///< @private

  inline simdjson_result<dom::element> at_pointer(std::string_view json_pointer) const noexcept;
-  inline simdjson_result<dom::element> at_path(std::string_view json_path) const noexcept;
  inline simdjson_result<dom::element> at(size_t index) const noexcept;

 #if SIMDJSON_EXCEPTIONS
@@ -9,7 +9,6 @@

 #include "simdjson/dom/object-inl.h"
 #include "simdjson/error-inl.h"
-#include "simdjson/jsonpathutil.h"

 #include <ostream>
 #include <limits>
@@ -123,11 +122,6 @@ simdjson_inline simdjson_result<dom::element> simdjson_result<dom::element>::at_
  if (error()) { return error(); }
  return first.at_pointer(json_pointer);
 }
-simdjson_inline simdjson_result<dom::element> simdjson_result<dom::element>::at_path(const std::string_view json_path) const noexcept {
-  auto json_pointer = json_path_to_pointer_conversion(json_path);
-  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
-  return at_pointer(json_pointer);
-}
 #ifndef SIMDJSON_DISABLE_DEPRECATED_API
 [[deprecated("For standard compliance, use at_pointer instead, and prefix your pointers with a slash '/', see RFC6901 ")]]
 simdjson_inline simdjson_result<dom::element> simdjson_result<dom::element>::at(const std::string_view json_pointer) const noexcept {
@@ -418,11 +412,6 @@ inline simdjson_result<element> element::at_pointer(std::string_view json_pointe
    }
  }
 }
-inline simdjson_result<element> element::at_path(std::string_view json_path) const noexcept {
-  auto json_pointer = json_path_to_pointer_conversion(json_path);
-  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
-  return at_pointer(json_pointer);
-}
 #ifndef SIMDJSON_DISABLE_DEPRECATED_API
 [[deprecated("For standard compliance, use at_pointer instead, and prefix your pointers with a slash '/', see RFC6901 ")]]
 inline simdjson_result<element> element::at(std::string_view json_pointer) const noexcept {
@@ -397,21 +397,6 @@ public:
   */
  inline simdjson_result<element> at_pointer(const std::string_view json_pointer) const noexcept;

-  /**
-   * Get the value associated with the given JSONPath expression. We only support
-   * JSONPath queries that trivially convertible to JSON Pointer queries: key
-   * names and array indices.
-   *
-   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
-   *
-   * @return The value associated with the given JSONPath expression, or:
-   *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails
-   *         - NO_SUCH_FIELD if a field does not exist in an object
-   *         - INDEX_OUT_OF_BOUNDS if an array index is larger than an array length
-   *         - INCORRECT_TYPE if a non-integer is used to access an array
-  */
-  inline simdjson_result<element> at_path(std::string_view json_path) const noexcept;
-
 #ifndef SIMDJSON_DISABLE_DEPRECATED_API
  /**
   *
@@ -541,7 +526,6 @@ public:
  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;
  simdjson_inline simdjson_result<dom::element> at_pointer(const std::string_view json_pointer) const noexcept;
-  simdjson_inline simdjson_result<dom::element> at_path(const std::string_view json_path) const noexcept;
  [[deprecated("For standard compliance, use at_pointer instead, and prefix your pointers with a slash '/', see RFC6901 ")]]
  simdjson_inline simdjson_result<dom::element> at(const std::string_view json_pointer) const noexcept;
  simdjson_inline simdjson_result<dom::element> at(size_t index) const noexcept;
@@ -7,7 +7,6 @@

 #include "simdjson/dom/element-inl.h"
 #include "simdjson/error-inl.h"
-#include "simdjson/jsonpathutil.h"

 #include <cstring>

@@ -35,11 +34,6 @@ inline simdjson_result<dom::element> simdjson_result<dom::object>::at_pointer(st
  if (error()) { return error(); }
  return first.at_pointer(json_pointer);
 }
-inline simdjson_result<dom::element> simdjson_result<dom::object>::at_path(std::string_view json_path) const noexcept {
-  auto json_pointer = json_path_to_pointer_conversion(json_path);
-  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
-  return at_pointer(json_pointer);
-}
 inline simdjson_result<dom::element> simdjson_result<dom::object>::at_key(std::string_view key) const noexcept {
  if (error()) { return error(); }
  return first.at_key(key);
@@ -137,12 +131,6 @@ inline simdjson_result<element> object::at_pointer(std::string_view json_pointer
  return child;
 }

-inline simdjson_result<element> object::at_path(std::string_view json_path) const noexcept {
-  auto json_pointer = json_path_to_pointer_conversion(json_path);
-  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
-  return at_pointer(json_pointer);
-}
-
 inline simdjson_result<element> object::at_key(std::string_view key) const noexcept {
  iterator end_field = end();
  for (iterator field = begin(); field != end_field; ++field) {
@@ -171,21 +171,6 @@ public:
   */
  inline simdjson_result<element> at_pointer(std::string_view json_pointer) const noexcept;

-  /**
-   * Get the value associated with the given JSONPath expression. We only support
-   * JSONPath queries that trivially convertible to JSON Pointer queries: key
-   * names and array indices.
-   *
-   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
-   *
-   * @return The value associated with the given JSONPath expression, or:
-   *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails
-   *         - NO_SUCH_FIELD if a field does not exist in an object
-   *         - INDEX_OUT_OF_BOUNDS if an array index is larger than an array length
-   *         - INCORRECT_TYPE if a non-integer is used to access an array
-  */
-  inline simdjson_result<element> at_path(std::string_view json_path) const noexcept;
-
  /**
   * Get the value associated with the given key.
   *
@@ -259,7 +244,6 @@ public:
  inline simdjson_result<dom::element> operator[](std::string_view key) const noexcept;
  inline simdjson_result<dom::element> operator[](const char *key) const noexcept;
  inline simdjson_result<dom::element> at_pointer(std::string_view json_pointer) const noexcept;
-  inline simdjson_result<dom::element> at_path(std::string_view json_path) const noexcept;
  inline simdjson_result<dom::element> at_key(std::string_view key) const noexcept;
  inline simdjson_result<dom::element> at_key_case_insensitive(std::string_view key) const noexcept;

@@ -549,14 +549,9 @@ public:
  /**
   * The parser instance can use threads when they are available to speed up some
   * operations. It is enabled by default. Changing this attribute will change the
-   * behavior of the parser for future operations. Set to true by default.
+   * behavior of the parser for future operations.
   */
  bool threaded{true};
-#else
-  /**
-   * When SIMDJSON_THREADS_ENABLED is not defined, the parser instance cannot use threads.
-   */
-  bool threaded{false};
 #endif
  /** @private Use the new DOM API instead */
  class Iterator;
@@ -75,12 +75,6 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace fallback
 } // namespace simdjson

-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif

 #endif // SIMDJSON_FALLBACK_NUMBERPARSING_DEFS_H
@@ -574,6 +574,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
  //
  // Check for minus sign
  //
@@ -2,7 +2,6 @@

 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
 #define SIMDJSON_GENERIC_ONDEMAND_ARRAY_INL_H
-#include "simdjson/jsonpathutil.h"
 #include "simdjson/generic/ondemand/base.h"
 #include "simdjson/generic/ondemand/array.h"
 #include "simdjson/generic/ondemand/array_iterator-inl.h"
@@ -164,6 +163,53 @@ inline simdjson_result<value> array::at_pointer(std::string_view json_pointer) n
  return child;
 }

+inline std::string json_path_to_pointer_conversion(std::string_view json_path) {
+  if (json_path.empty() || (json_path.front() != '.' &&
+      json_path.front() != '[')) {
+    return "-1"; // This is just a sentinel value, the caller should check for this and return an error.
+  }
+
+  std::string result;
+  // Reserve space to reduce allocations, adjusting for potential increases due
+  // to escaping.
+  result.reserve(json_path.size() * 2);
+
+  size_t i = 0;
+
+  while (i < json_path.length()) {
+    if (json_path[i] == '.') {
+      result += '/';
+    } else if (json_path[i] == '[') {
+      result += '/';
+      ++i; // Move past the '['
+      while (i < json_path.length() && json_path[i] != ']') {
+          if (json_path[i] == '~') {
+            result += "~0";
+          } else if (json_path[i] == '/') {
+            result += "~1";
+          } else {
+            result += json_path[i];
+          }
+          ++i;
+      }
+      if (i == json_path.length() || json_path[i] != ']') {
+          return "-1"; // Using sentinel value that will be handled as an error by the caller.
+      }
+    } else {
+      if (json_path[i] == '~') {
+          result += "~0";
+      } else if (json_path[i] == '/') {
+          result += "~1";
+      } else {
+          result += json_path[i];
+      }
+    }
+    ++i;
+  }
+
+  return result;
+}
+
 inline simdjson_result<value> array::at_path(std::string_view json_path) noexcept {
  auto json_pointer = json_path_to_pointer_conversion(json_path);
  if (json_pointer == "-1") { return INVALID_JSON_POINTER; }
@@ -13,6 +13,5 @@
 #include "simdjson/padded_string.h"
 #include "simdjson/padded_string_view.h"
 #include "simdjson/internal/dom_parser_implementation.h"
-#include "simdjson/jsonpathutil.h"

 #endif // SIMDJSON_GENERIC_ONDEMAND_DEPENDENCIES_H
@@ -691,11 +691,6 @@ protected:

 /**
 * A document_reference is a thin wrapper around a document reference instance.
- * The document_reference instances are used primarily/solely for streams of JSON
- * documents. They differ from document instances when parsing a scalar value
- * (a document that is not an array or an object). In the case of a document,
- * we expect the document to be fully consumed. In the case of a document_reference,
- * we allow trailing content.
 */
 class document_reference {
 public:
@@ -278,12 +278,8 @@ public:
   * behavior of the parser for future operations.
   */
  bool threaded{true};
-  #else
-  /**
-   * When SIMDJSON_THREADS_ENABLED is not defined, the parser instance cannot use threads.
-   */
-  bool threaded{false};
  #endif
+
  /**
   * Unescape this JSON string, replacing \\ with \, \n with newline, etc. to a user-provided buffer.
   * The result must be valid UTF-8.
@@ -799,8 +799,6 @@ simdjson_inline simdjson_result<bool> value_iterator::is_root_null(bool check_tr
  if(result) { // we have something that looks like a null.
    if (check_trailing && !_json_iter->is_single_token()) { return TRAILING_CONTENT; }
    advance_root_scalar("null");
-  } else if (json[0] == 'n') {
-    return incorrect_type_error("Not a null but starts with n");
  }
  return result;
 }
@@ -4,14 +4,8 @@
 #include "simdjson/haswell/intrinsics.h"

 #if !SIMDJSON_CAN_ALWAYS_RUN_HASWELL
-// We enable bmi2 only if LLVM/clang is used, because GCC may not
-// make good use of it. See https://github.com/simdjson/simdjson/pull/2243
-#if defined(__clang__)
-SIMDJSON_TARGET_REGION("avx2,bmi,bmi2,pclmul,lzcnt,popcnt")
-#else
 SIMDJSON_TARGET_REGION("avx2,bmi,pclmul,lzcnt,popcnt")
 #endif
-#endif

 #include "simdjson/haswell/bitmanipulation.h"
 #include "simdjson/haswell/bitmask.h"
@@ -295,6 +295,30 @@ namespace simd {
    simdjson_inline int get_bit() const { return _mm256_movemask_epi8(_mm256_slli_epi16(*this, 7-N)); }
  };

+  template <int N = 0>
+  struct simd_bitmask64_builder;
+
+  template<>
+  struct simd_bitmask64_builder<2> {
+    const uint64_t bitmask;
+    operator uint64_t() && { return bitmask; }
+  }; // struct simd_bitmask64_builder<2>
+
+  template<>
+  struct simd_bitmask64_builder<1> {
+    const int bitmask;
+    simdjson_inline simd_bitmask64_builder<2> next(simd8<bool> val) {
+      uint64_t r_lo = uint32_t(bitmask);
+      uint64_t r_hi = val.to_bitmask();
+      return { r_lo | (r_hi << 32) };
+    }
+  }; // struct simd_bitmask64_builder<1>
+
+  template<>
+  struct simd_bitmask64_builder<0> {
+    simdjson_inline simd_bitmask64_builder<1> next(simd8<bool> val) { return { val.to_bitmask() }; }
+  }; // struct simd_bitmask64_builder<0>
+
  template<typename T>
  struct simd8x64 {
    static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
@@ -322,9 +346,9 @@ namespace simd {
    }

    simdjson_inline uint64_t to_bitmask() const {
-      uint64_t r_lo = uint32_t(this->chunks[0].to_bitmask());
-      uint64_t r_hi =                       this->chunks[1].to_bitmask();
-      return r_lo | (r_hi << 32);
+      return simd_bitmask64_builder<0>()
+        .next(this->chunks[0])
+        .next(this->chunks[1]);
    }

    simdjson_inline simd8<T> reduce_or() const {
@@ -314,6 +314,20 @@ namespace simd {
    simdjson_inline uint64_t get_bit() const { return _mm512_movepi8_mask(_mm512_slli_epi16(*this, 7-N)); }
  };

+  template <int N = 0>
+  struct simd_bitmask64_builder;
+
+  template<>
+  struct simd_bitmask64_builder<1> {
+    const __mmask64 bitmask;
+    operator __mmask64() && { return bitmask; }
+  }; // struct simd_bitmask64_builder<2>
+
+  template<>
+  struct simd_bitmask64_builder<0> {
+    simdjson_inline simd_bitmask64_builder<1> next(simd8<bool> val) { return { _mm512_movepi8_mask(val) }; }
+  }; // struct simd_bitmask64_builder<0>
+
  template<typename T>
  struct simd8x64 {
    static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
@@ -1,64 +0,0 @@
-#ifndef SIMDJSON_JSONPATHUTIL_H
-#define SIMDJSON_JSONPATHUTIL_H
-
-#include <string>
-#include <string_view>
-
-namespace simdjson {
-/**
- * Converts JSONPath to JSON Pointer.
- * @param json_path The JSONPath string to be converted.
- * @return A string containing the equivalent JSON Pointer.
- */
-inline std::string json_path_to_pointer_conversion(std::string_view json_path) {
-  size_t i = 0;
-
-  // if JSONPath starts with $, skip it
-  if (!json_path.empty() && json_path.front() == '$') {
-    i = 1;
-  }
-  if (json_path.empty() || (json_path[i] != '.' &&
-      json_path[i] != '[')) {
-    return "-1"; // This is just a sentinel value, the caller should check for this and return an error.
-  }
-
-  std::string result;
-  // Reserve space to reduce allocations, adjusting for potential increases due
-  // to escaping.
-  result.reserve(json_path.size() * 2);
-
-  while (i < json_path.length()) {
-    if (json_path[i] == '.') {
-      result += '/';
-    } else if (json_path[i] == '[') {
-      result += '/';
-      ++i; // Move past the '['
-      while (i < json_path.length() && json_path[i] != ']') {
-          if (json_path[i] == '~') {
-            result += "~0";
-          } else if (json_path[i] == '/') {
-            result += "~1";
-          } else {
-            result += json_path[i];
-          }
-          ++i;
-      }
-      if (i == json_path.length() || json_path[i] != ']') {
-          return "-1"; // Using sentinel value that will be handled as an error by the caller.
-      }
-    } else {
-      if (json_path[i] == '~') {
-          result += "~0";
-      } else if (json_path[i] == '/') {
-          result += "~1";
-      } else {
-          result += json_path[i];
-      }
-    }
-    ++i;
-  }
-
-  return result;
-}
-} // namespace simdjson
-#endif // SIMDJSON_JSONPATHUTIL_H
@@ -36,12 +36,6 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace lasx
 } // namespace simdjson

-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif

 #endif // SIMDJSON_LASX_NUMBERPARSING_DEFS_H
@@ -298,6 +298,35 @@ namespace simd {
    simdjson_inline simd8<uint8_t> shl() const { return simd8<uint8_t>(__lasx_xvslli_b(*this, N)); }
  };

+  template <int N = 0>
+  struct simd_bitmask64_builder;
+
+  template<>
+  struct simd_bitmask64_builder<2> {
+    const unsigned long int mask01;
+    operator uint64_t() { return mask01; }
+  }; // struct simd_bitmask64_builder<2>
+
+  template<>
+  struct simd_bitmask64_builder<1> {
+    const __m256i mask0;
+    simdjson_inline simd_bitmask64_builder<2> next(simd8<bool> val1) {
+      __m256i mask1 = __lasx_xvmskltz_b(val1);
+      __m256i mask_tmp = __lasx_xvpickve_w(mask0, 4);
+      __m256i tmp = __lasx_xvpickve_w(mask1, 4);
+      __m256i mask01 = __lasx_xvinsve0_w(mask0, mask1, 1);
+      __m256i mask01_tmp = __lasx_xvinsve0_w(mask_tmp, tmp, 1);
+      return { __lasx_xvpickve2gr_du(__lasx_xvpackev_h(mask01_tmp, mask01), 0) };
+    }
+  }; // struct simd_bitmask64_builder<1>
+
+  template<>
+  struct simd_bitmask64_builder<0> {
+    simdjson_inline simd_bitmask64_builder<1> next(simd8<bool> val) {
+      return { __lasx_xvmskltz_b(val0) };
+    }
+  }; // struct simd_bitmask64_builder<0>
+
  template<typename T>
  struct simd8x64 {
    static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
@@ -331,13 +360,9 @@ namespace simd {
    }

    simdjson_inline uint64_t to_bitmask() const {
-      __m256i mask0 = __lasx_xvmskltz_b(this->chunks[0]);
-      __m256i mask1 = __lasx_xvmskltz_b(this->chunks[1]);
-      __m256i mask_tmp = __lasx_xvpickve_w(mask0, 4);
-      __m256i tmp = __lasx_xvpickve_w(mask1, 4);
-      mask0 = __lasx_xvinsve0_w(mask0, mask1, 1);
-      mask_tmp = __lasx_xvinsve0_w(mask_tmp, tmp, 1);
-      return __lasx_xvpickve2gr_du(__lasx_xvpackev_h(mask_tmp, mask0), 0);
+      return simd_bitmask64_builder<0>()
+        .next(this->chunks[0])
+        .next(this->chunks[1]);
    }

    simdjson_inline simd8<T> reduce_or() const {
@@ -36,12 +36,6 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace lsx
 } // namespace simdjson

-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif

 #endif // SIMDJSON_LSX_NUMBERPARSING_DEFS_H
@@ -255,6 +255,50 @@ namespace simd {
    simdjson_inline simd8<uint8_t> shl() const { return simd8<uint8_t>(__lsx_vslli_b(*this, N)); }
  };

+  template <int N = 0>
+  struct simd_bitmask64_builder;
+
+  template<>
+  struct simd_bitmask64_builder<4> {
+    const unsigned long int result;
+    operator uint64_t() { return result; }
+  }; // struct simd_bitmask64_builder<4>
+
+  template<>
+  struct simd_bitmask64_builder<3> {
+    const __m128i mask01;
+    const __m128i mask2;
+    simdjson_inline simd_bitmask64_builder<4> next(simd8<bool> val3) {
+      __m128i mask3 = __lsx_vmskltz_b(val3);
+      __m128i mask23 = __lsx_vilvl_h(mask3, mask2);
+      return { __lsx_vpickve2gr_du(__lsx_vilvl_w(mask23, mask01), 0) };
+    }
+  }; // struct simd_bitmask64_builder<3>
+
+  template<>
+  struct simd_bitmask64_builder<2> {
+    const __m128i mask01;
+    simdjson_inline simd_bitmask64_builder<3> next(simd8<bool> val2) {
+      return { mask01, __lsx_vmskltz_b(val2) };
+    }
+  }; // struct simd_bitmask64_builder<2>
+
+  template<>
+  struct simd_bitmask64_builder<1> {
+    const __m128i mask0;
+    simdjson_inline simd_bitmask64_builder<2> next(simd8<bool> val1) {
+      __m128i mask1 = __lsx_vmskltz_b(val1);
+      return { __lsx_vilvl_h(mask1, mask0) };
+    }
+  }; // struct simd_bitmask64_builder<1>
+
+  template<>
+  struct simd_bitmask64_builder<0> {
+    simdjson_inline simd_bitmask64_builder<1> next(simd8<bool> val0) {
+      return { __lsx_vmskltz_b(val0) };
+    }
+  }; // struct simd_bitmask64_builder<0>
+
  template<typename T>
  struct simd8x64 {
    static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
@@ -303,13 +347,11 @@ namespace simd {
    }

    simdjson_inline uint64_t to_bitmask() const {
-      __m128i mask1 = __lsx_vmskltz_b(this->chunks[0]);
-      __m128i mask2 = __lsx_vmskltz_b(this->chunks[1]);
-      __m128i mask3 = __lsx_vmskltz_b(this->chunks[2]);
-      __m128i mask4 = __lsx_vmskltz_b(this->chunks[3]);
-      mask1 = __lsx_vilvl_h(mask2, mask1);
-      mask2 = __lsx_vilvl_h(mask4, mask3);
-      return __lsx_vpickve2gr_du(__lsx_vilvl_w(mask2, mask1), 0);
+      return simd_bitmask64_builder<0>()
+        .next(this->chunks[0])
+        .next(this->chunks[1])
+        .next(this->chunks[2])
+        .next(this->chunks[3]);
    }

    simdjson_inline simd8<T> reduce_or() const {
@@ -53,9 +53,6 @@ inline padded_string::padded_string(const char *data, size_t length) noexcept
  if ((data != nullptr) && (data_ptr != nullptr)) {
    std::memcpy(data_ptr, data, length);
  }
-  if (data_ptr == nullptr) {
-    viable_size = 0;
-  }
 }
 #ifdef __cpp_char8_t
 inline padded_string::padded_string(const char8_t *data, size_t length) noexcept
@@ -63,17 +60,12 @@ inline padded_string::padded_string(const char8_t *data, size_t length) noexcept
  if ((data != nullptr) && (data_ptr != nullptr)) {
    std::memcpy(data_ptr, reinterpret_cast<const char *>(data), length);
  }
-  if (data_ptr == nullptr) {
-    viable_size = 0;
-  }
 }
 #endif
 // note: do not pass std::string arguments by value
 inline padded_string::padded_string(const std::string & str_ ) noexcept
    : viable_size(str_.size()), data_ptr(internal::allocate_padded_buffer(str_.size())) {
-  if (data_ptr == nullptr) {
-    viable_size = 0;
-  } else {
+  if (data_ptr != nullptr) {
    std::memcpy(data_ptr, str_.data(), str_.size());
  }
 }
@@ -201,43 +201,4 @@ using std::size_t;

 #endif

-
-
-#if defined __BYTE_ORDER__ && defined __ORDER_BIG_ENDIAN__
-#define SIMDJSON_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-#elif defined _WIN32
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#else
-#if defined(__APPLE__) || defined(__FreeBSD__)
-#include <machine/endian.h>
-#elif defined(sun) || defined(__sun)
-#include <sys/byteorder.h>
-#elif defined(__MVS__)
-#include <sys/endian.h>
-#else
-#ifdef __has_include
-#if __has_include(<endian.h>)
-#include <endian.h>
-#endif //__has_include(<endian.h>)
-#endif //__has_include
-#endif
-#
-#ifndef __BYTE_ORDER__
-// safe choice
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#endif
-#
-#ifndef __ORDER_LITTLE_ENDIAN__
-// safe choice
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#endif
-#
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#else
-#define SIMDJSON_IS_BIG_ENDIAN 1
-#endif
-#endif
-
-
 #endif // SIMDJSON_PORTABILITY_H
@@ -60,12 +60,6 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace ppc64
 } // namespace simdjson

-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif

 #endif // SIMDJSON_PPC64_NUMBERPARSING_DEFS_H
@@ -392,6 +392,51 @@ template <> struct simd8<uint8_t> : base8_numeric<uint8_t> {
  }
 };

+template <int N = 0>
+struct simd_bitmask64_builder;
+
+template<>
+struct simd_bitmask64_builder<4> {
+  const uint64_t bitmask;
+  simdjson_inline operator uint64_t() && { return bitmask; }
+}; // struct simd_bitmask64_builder<4>
+
+template<>
+struct simd_bitmask64_builder<3> {
+  const int bitmask01;
+  const int bitmask2;
+  simdjson_inline simd_bitmask64_builder<4> next(simd8<bool> val) {
+    return {
+      uint64_t(this->bitmask01) |
+      (uint64_t(this->bitmask2) << 32) |
+      (uint64_t(val.to_bitmask()) << 48)
+    };
+  }
+}; // struct simd_bitmask64_builder<3>
+
+template<>
+struct simd_bitmask64_builder<2> {
+  const int bitmask01;
+  simdjson_inline simd_bitmask64_builder<3> next(simd8<bool> val) {
+    return { bitmask01, val.to_bitmask() };
+  }
+}; // struct simd_bitmask64_builder<2>
+
+template<>
+struct simd_bitmask64_builder<1> {
+  const int bitmask0;
+  simdjson_inline simd_bitmask64_builder<2> next(simd8<bool> val) {
+    return { bitmask0 | (val.to_bitmask() << 16) };
+  }
+}; // struct simd_bitmask64_builder<1>
+
+template<>
+struct simd_bitmask64_builder<0> {
+  simdjson_inline simd_bitmask64_builder<1> next(simd8<bool> val) {
+    return { val.to_bitmask() };
+  }
+}; // struct simd_bitmask64_builder<0>
+
 template <typename T> struct simd8x64 {
  static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
  static_assert(NUM_CHUNKS == 4,
@@ -434,11 +479,11 @@ template <typename T> struct simd8x64 {
  }

  simdjson_inline uint64_t to_bitmask() const {
-    uint64_t r0 = uint32_t(this->chunks[0].to_bitmask());
-    uint64_t r1 = this->chunks[1].to_bitmask();
-    uint64_t r2 = this->chunks[2].to_bitmask();
-    uint64_t r3 = this->chunks[3].to_bitmask();
-    return r0 | (r1 << 16) | (r2 << 32) | (r3 << 48);
+      return simd_bitmask64_builder<0>()
+        .next(this->chunks[0])
+        .next(this->chunks[1])
+        .next(this->chunks[2])
+        .next(this->chunks[3]);
  }

  simdjson_inline uint64_t eq(const T m) const {
@@ -4,7 +4,7 @@
 #define SIMDJSON_SIMDJSON_VERSION_H

 /** The version of simdjson being used (major.minor.revision) */
-#define SIMDJSON_VERSION "3.10.1"
+#define SIMDJSON_VERSION "3.10.0"

 namespace simdjson {
 enum {
@@ -19,7 +19,7 @@ enum {
  /**
   * The revision (major.minor.REVISION) of simdjson being used.
   */
-  SIMDJSON_VERSION_REVISION = 1
+  SIMDJSON_VERSION_REVISION = 0
 };
 } // namespace simdjson

@@ -260,6 +260,51 @@ namespace simd {
    simdjson_inline int get_bit() const { return _mm_movemask_epi8(_mm_slli_epi16(*this, 7-N)); }
  };

+  template <int N = 0>
+  struct simd_bitmask64_builder;
+
+  template<>
+  struct simd_bitmask64_builder<4> {
+    const uint64_t bitmask;
+    operator uint64_t() && { return bitmask; }
+  }; // struct simd_bitmask64_builder<4>
+
+  template<>
+  struct simd_bitmask64_builder<3> {
+    uint32_t bitmask01;
+    const int bitmask2;
+    simdjson_inline simd_bitmask64_builder<4> next(simd8<bool> val3) {
+      return {
+        uint64_t(this->bitmask01) |
+        (uint64_t(this->bitmask2) << 32) |
+        (uint64_t(val3.to_bitmask()) << 48)
+      };
+    }
+  }; // struct simd_bitmask64_builder<3>
+
+  template<>
+  struct simd_bitmask64_builder<2> {
+    uint32_t bitmask01;
+    simdjson_inline simd_bitmask64_builder<3> next(simd8<bool> val2) {
+      return { bitmask01, val2.to_bitmask() };
+    }
+  }; // struct simd_bitmask64_builder<2>
+
+  template<>
+  struct simd_bitmask64_builder<1> {
+    const int bitmask0;
+    simdjson_inline simd_bitmask64_builder<2> next(simd8<bool> val1) {
+      return { uint32_t(bitmask0) | (uint32_t(val1.to_bitmask()) << 16) };
+    }
+  }; // struct simd_bitmask64_builder<1>
+
+  template<>
+  struct simd_bitmask64_builder<0> {
+    simdjson_inline simd_bitmask64_builder<1> next(simd8<bool> val0) {
+      return { val0.to_bitmask() };
+    }
+  }; // struct simd_bitmask64_builder<0>
+
  template<typename T>
  struct simd8x64 {
    static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
@@ -293,11 +338,11 @@ namespace simd {
    }

    simdjson_inline uint64_t to_bitmask() const {
-      uint64_t r0 = uint32_t(this->chunks[0].to_bitmask() );
-      uint64_t r1 =          this->chunks[1].to_bitmask() ;
-      uint64_t r2 =          this->chunks[2].to_bitmask() ;
-      uint64_t r3 =          this->chunks[3].to_bitmask() ;
-      return r0 | (r1 << 16) | (r2 << 32) | (r3 << 48);
+      return simd_bitmask64_builder<0>()
+        .next(this->chunks[0])
+        .next(this->chunks[1])
+        .next(this->chunks[2])
+        .next(this->chunks[3]);
    }

    simdjson_inline uint64_t eq(const T m) const {
@@ -323,10 +323,6 @@ class Amalgamator:
            for line in fid2:
                line = line.rstrip('\n')

-                # Ignore #pragma once, it causes warnings if it ends up in a .cpp file
-                if re.search(r'^#pragma once$', line):
-                    continue
-
                # Ignore lines inside #ifndef SIMDJSON_CONDITIONAL_INCLUDE
                if re.search(r'^#ifndef\s+SIMDJSON_CONDITIONAL_INCLUDE\s*$', line):
                    assert file.is_conditional_include, f"{file} uses #ifndef SIMDJSON_CONDITIONAL_INCLUDE but is not an amalgamated file!"
@@ -1,4 +1,4 @@
-/* auto-generated on 2024-09-17 15:48:50 -0400. Do not edit! */
+/* auto-generated on 2024-08-01 09:31:50 -0400. Do not edit! */
 /* including simdjson.cpp:  */
 /* begin file simdjson.cpp */
 #define SIMDJSON_SRC_SIMDJSON_CPP
@@ -284,45 +284,6 @@ using std::size_t;

 #endif

-
-
-#if defined __BYTE_ORDER__ && defined __ORDER_BIG_ENDIAN__
-#define SIMDJSON_IS_BIG_ENDIAN (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
-#elif defined _WIN32
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#else
-#if defined(__APPLE__) || defined(__FreeBSD__)
-#include <machine/endian.h>
-#elif defined(sun) || defined(__sun)
-#include <sys/byteorder.h>
-#elif defined(__MVS__)
-#include <sys/endian.h>
-#else
-#ifdef __has_include
-#if __has_include(<endian.h>)
-#include <endian.h>
-#endif //__has_include(<endian.h>)
-#endif //__has_include
-#endif
-#
-#ifndef __BYTE_ORDER__
-// safe choice
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#endif
-#
-#ifndef __ORDER_LITTLE_ENDIAN__
-// safe choice
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#endif
-#
-#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
-#define SIMDJSON_IS_BIG_ENDIAN 0
-#else
-#define SIMDJSON_IS_BIG_ENDIAN 1
-#endif
-#endif
-
-
 #endif // SIMDJSON_PORTABILITY_H
 /* end file simdjson/portability.h */

@@ -371,8 +332,6 @@ double from_chars(const char *first, const char* end) noexcept;
 #define SIMDJSON_ISALIGNED_N(ptr, n) (((uintptr_t)(ptr) & ((n)-1)) == 0)

 #if SIMDJSON_REGULAR_VISUAL_STUDIO
-  // We could use [[deprecated]] but it requires C++14
-  #define simdjson_deprecated __declspec(deprecated)

  #define simdjson_really_inline __forceinline
  #define simdjson_never_inline __declspec(noinline)
@@ -411,8 +370,6 @@ double from_chars(const char *first, const char* end) noexcept;
  #define SIMDJSON_POP_DISABLE_UNUSED_WARNINGS

 #else // SIMDJSON_REGULAR_VISUAL_STUDIO
-  // We could use [[deprecated]] but it requires C++14
-  #define simdjson_deprecated __attribute__((deprecated))

  #define simdjson_really_inline inline __attribute__((always_inline))
  #define simdjson_never_inline inline __attribute__((noinline))
@@ -588,6 +545,7 @@ SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
 // Distributed under the Boost Software License, Version 1.0.
 // (See accompanying file LICENSE.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

+#pragma once

 #ifndef NONSTD_SV_LITE_H_INCLUDED
 #define NONSTD_SV_LITE_H_INCLUDED
@@ -7677,12 +7635,6 @@ simdjson_inline uint64_t clear_lowest_bit(uint64_t input_num) {
  return input_num & (input_num-1);
 }

-// We sometimes call leading_zeroes on inputs that are zero,
-// but the algorithms do not end up using the returned value.
-// Sadly, sanitizers are not smart enough to figure it out.
-// Applies only when SIMDJSON_PREFER_REVERSE_BITS is defined and true.
-// (See below.)
-SIMDJSON_NO_SANITIZE_UNDEFINED
 /* result might be undefined when input_num is zero */
 simdjson_inline int leading_zeroes(uint64_t input_num) {
 #ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
@@ -7855,13 +7807,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace arm64
 } // namespace simdjson

-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif

 #endif // SIMDJSON_ARM64_NUMBERPARSING_DEFS_H
 /* end file simdjson/arm64/numberparsing_defs.h */
@@ -9478,6 +9424,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
  //
  // Check for minus sign
  //
@@ -10444,12 +10391,6 @@ simdjson_inline uint64_t clear_lowest_bit(uint64_t input_num) {
  return input_num & (input_num-1);
 }

-// We sometimes call leading_zeroes on inputs that are zero,
-// but the algorithms do not end up using the returned value.
-// Sadly, sanitizers are not smart enough to figure it out.
-// Applies only when SIMDJSON_PREFER_REVERSE_BITS is defined and true.
-// (See below.)
-SIMDJSON_NO_SANITIZE_UNDEFINED
 /* result might be undefined when input_num is zero */
 simdjson_inline int leading_zeroes(uint64_t input_num) {
 #ifdef SIMDJSON_REGULAR_VISUAL_STUDIO
@@ -10622,13 +10563,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace arm64
 } // namespace simdjson

-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif

 #endif // SIMDJSON_ARM64_NUMBERPARSING_DEFS_H
 /* end file simdjson/arm64/numberparsing_defs.h */
@@ -15831,6 +15766,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
  //
  // Check for minus sign
  //
@@ -22044,6 +21980,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
  //
  // Check for minus sign
  //
@@ -26809,13 +26746,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace ppc64
 } // namespace simdjson

-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif

 #endif // SIMDJSON_PPC64_NUMBERPARSING_DEFS_H
 /* end file simdjson/ppc64/numberparsing_defs.h */
@@ -28419,6 +28350,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
  //
  // Check for minus sign
  //
@@ -29558,13 +29490,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace ppc64
 } // namespace simdjson

-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif

 #endif // SIMDJSON_PPC64_NUMBERPARSING_DEFS_H
 /* end file simdjson/ppc64/numberparsing_defs.h */
@@ -35160,6 +35086,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
  //
  // Check for minus sign
  //
@@ -40245,13 +40172,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace lsx
 } // namespace simdjson

-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif

 #endif // SIMDJSON_LSX_NUMBERPARSING_DEFS_H
 /* end file simdjson/lsx/numberparsing_defs.h */
@@ -41725,6 +41646,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
  //
  // Check for minus sign
  //
@@ -42779,13 +42701,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace lsx
 } // namespace simdjson

-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif

 #endif // SIMDJSON_LSX_NUMBERPARSING_DEFS_H
 /* end file simdjson/lsx/numberparsing_defs.h */
@@ -46239,13 +46155,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace lasx
 } // namespace simdjson

-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif

 #endif // SIMDJSON_LASX_NUMBERPARSING_DEFS_H
 /* end file simdjson/lasx/numberparsing_defs.h */
@@ -47735,6 +47645,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
  //
  // Check for minus sign
  //
@@ -48789,13 +48700,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace lasx
 } // namespace simdjson

-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif

 #endif // SIMDJSON_LASX_NUMBERPARSING_DEFS_H
 /* end file simdjson/lasx/numberparsing_defs.h */
@@ -52279,13 +52184,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace fallback
 } // namespace simdjson

-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif

 #endif // SIMDJSON_FALLBACK_NUMBERPARSING_DEFS_H
 /* end file simdjson/fallback/numberparsing_defs.h */
@@ -53344,6 +53243,7 @@ simdjson_unused simdjson_inline simdjson_result<number_type> get_number_type(con
 // Our objective is accurate parsing (ULP of 0) at high speed.
 template<typename W>
 simdjson_inline error_code parse_number(const uint8_t *const src, W &writer) {
+
  //
  // Check for minus sign
  //
@@ -54418,13 +54318,7 @@ simdjson_inline internal::value128 full_multiplication(uint64_t value1, uint64_t
 } // namespace fallback
 } // namespace simdjson

-#ifndef SIMDJSON_SWAR_NUMBER_PARSING
-#if SIMDJSON_IS_BIG_ENDIAN
-#define SIMDJSON_SWAR_NUMBER_PARSING 0
-#else
 #define SIMDJSON_SWAR_NUMBER_PARSING 1
-#endif
-#endif

 #endif // SIMDJSON_FALLBACK_NUMBERPARSING_DEFS_H
 /* end file simdjson/fallback/numberparsing_defs.h */
@@ -12,7 +12,6 @@ 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(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)
 add_cpp_test(numberparsingcheck         LABELS dom acceptance per_implementation) # https://tools.ietf.org/html/rfc6901
 add_cpp_test(parse_many_test            LABELS dom acceptance per_implementation)
@@ -1,350 +0,0 @@
-/**
- * refer to pathcheck.cpp
- */
-
-#include <iostream>
-#include <string>
-using namespace std::string_literals;
-
-#include "simdjson.h"
-#include "test_macros.h"
-
-// we define our own asserts to get around NDEBUG
-#ifndef ASSERT
-#define ASSERT(x)                                                              \
-  {                                                                            \
-    if (!(x)) {                                                                \
-      std::cerr << "Failed assertion " << #x << std::endl;                     \
-      return false;                                                            \
-    }                                                                          \
-  }
-#endif
-
-using namespace simdjson;
-
-bool demo() {
-#if SIMDJSON_EXCEPTIONS
-  std::cout << "demo test" << std::endl;
-  auto cars_json = R"( [
-  { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
-  { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
-  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
-] )"_padded;
-  dom::parser parser;
-  dom::element cars = parser.parse(cars_json);
-  double x = cars.at_path("$[0].tire_pressure[1]");
-  if (x != 39.9)
-    return false;
-  // Iterating through an array of objects
-  std::vector<double> measured;
-  for (dom::element car_element : cars) {
-    dom::object car;
-    simdjson::error_code error;
-    if ((error = car_element.get(car))) {
-      std::cerr << error << std::endl;
-      return false;
-    }
-    double x3 = car.at_path("$.tire_pressure[1]");
-    measured.push_back(x3);
-  }
-  std::vector<double> expected = {39.9, 31, 30};
-  if (measured != expected) {
-    return false;
-  }
-#endif
-  return true;
-}
-
-const padded_string TEST_JSON = R"(
-  {
-    "/~01abc": [
-      0,
-      {
-        "\\\" 0": [
-          "value0",
-          "value1"
-        ]
-      }
-    ],
-    "0": "0 ok",
-    "01": "01 ok",
-    "": "empty ok",
-    "arr": []
-  }
-)"_padded;
-
-const padded_string TEST_RFC_JSON = R"(
-   {
-      "foo": ["bar", "baz"],
-      "": 0,
-      "a/b": 1,
-      "c%d": 2,
-      "e^f": 3,
-      "g|h": 4,
-      "i\\j": 5,
-      "k\"l": 6,
-      " ": 7,
-      "m~n": 8
-   }
-)"_padded;
-
-bool run_success_test(const padded_string &source, const char *json_path,
-                      std::string_view expected_value) {
-  std::cout << "Running successful JSONPath test '" << json_path << "' ..."
-            << std::endl;
-  dom::parser parser;
-  dom::element doc;
-  auto error = parser.parse(source).get(doc);
-  if (error) {
-    std::cerr << "cannot parse: " << error << std::endl;
-    return false;
-  }
-  dom::element answer;
-  error = doc.at_path(json_path).get(answer);
-  if (error) {
-    std::cerr << "cannot access pointer: " << error << std::endl;
-    return false;
-  }
-  std::string str_answer = simdjson::minify(answer);
-  if (str_answer != expected_value) {
-    std::cerr << "They differ!!!" << std::endl;
-    std::cerr << "   found    '" << str_answer << "'" << std::endl;
-    std::cerr << "   expected '" << expected_value << "'" << std::endl;
-  }
-  ASSERT_EQUAL(str_answer, expected_value);
-  return true;
-}
-
-bool run_failure_test(const padded_string &source, const char *json_path,
-                      error_code expected_error) {
-  std::cout << "Running invalid JSONPath test '" << json_path << "' ..."
-            << std::endl;
-  dom::parser parser;
-  ASSERT_ERROR(parser.parse(source).at_path(json_path).error(), expected_error);
-  return true;
-}
-
-bool demo_relative_path() {
-  TEST_START();
-  auto cars_json = R"( [
-        { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
-        { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
-        { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
-        ] )"_padded;
-
-  dom::parser parser;
-  dom::element cars;
-  std::vector<double> measured;
-  auto error = parser.parse(cars_json).get(cars);
-  if (error) {
-    std::cerr << "cannot parse: " << error << std::endl;
-    return false;
-  }
-  dom::array cars_array;
-  error = cars.get(cars_array);
-  if (error) {
-    std::cerr << "cannot get array: " << error << std::endl;
-    return false;
-  }
-  for (auto car_element : cars_array) {
-    double x;
-    ASSERT_SUCCESS(car_element.at_path(".tire_pressure[1]").get(x));
-    measured.push_back(x);
-  }
-
-  std::vector<double> expected = {39.9, 31, 30};
-  if (measured != expected) {
-    return false;
-  }
-  TEST_SUCCEED();
-}
-
-bool many_json_paths() {
-  TEST_START();
-  auto cars_json = R"( [
-        { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
-        { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
-        { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
-        ] )"_padded;
-
-  dom::parser parser;
-  dom::element cars;
-  std::vector<double> measured;
-  ASSERT_SUCCESS(parser.parse(cars_json).get(cars));
-  for (int i = 0; i < 3; i++) {
-    double x;
-    std::string json_path = std::string("$[") + std::to_string(i) +
-                            std::string("].tire_pressure[1]");
-    ASSERT_SUCCESS(cars.at_path(json_path).get(x));
-    measured.push_back(x);
-  }
-
-  std::vector<double> expected = {39.9, 31, 30};
-  if (measured != expected) {
-    return false;
-  }
-  TEST_SUCCEED();
-}
-
-bool many_json_paths_object_array() {
-  TEST_START();
-  auto dogcatpotato =
-      R"( { "dog" : [1,2,3], "cat" : [5, 6, 7], "potato" : [1234]})"_padded;
-
-  dom::parser parser;
-  dom::element doc;
-  ASSERT_SUCCESS(parser.parse(dogcatpotato).get(doc));
-  dom::object obj;
-  ASSERT_SUCCESS(doc.get_object().get(obj));
-  int64_t x;
-  ASSERT_SUCCESS(obj.at_path("$.dog[1]").get(x));
-  ASSERT_EQUAL(x, 2);
-  ASSERT_SUCCESS(obj.at_path("$.potato[0]").get(x));
-  ASSERT_EQUAL(x, 1234);
-  TEST_SUCCEED();
-}
-bool many_json_paths_object() {
-  TEST_START();
-  auto cfoofoo2 =
-      R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
-  dom::parser parser;
-  dom::element doc;
-  ASSERT_SUCCESS(parser.parse(cfoofoo2).get(doc));
-  dom::object obj;
-  ASSERT_SUCCESS(doc.get_object().get(obj));
-  int64_t x;
-  ASSERT_SUCCESS(obj.at_path("$.c.foo.a[1]").get(x));
-  ASSERT_EQUAL(x, 20);
-  ASSERT_SUCCESS(obj.at_path("$.d.foo2.a.2").get(x));
-  ASSERT_EQUAL(x, 30);
-  ASSERT_SUCCESS(obj.at_path("$.e").get(x));
-  ASSERT_EQUAL(x, 120);
-  TEST_SUCCEED();
-}
-bool many_json_paths_array() {
-  TEST_START();
-  auto cfoofoo2 =
-      R"( [ 111, 2, 3, { "foo": { "a": [ 10, 20, 33 ] }}, { "foo2": { "a": [ 10, 20, 30 ] }}, 1001 ])"_padded;
-  dom::parser parser;
-  dom::element doc;
-  ASSERT_SUCCESS(parser.parse(cfoofoo2).get(doc));
-  dom::array arr;
-  ASSERT_SUCCESS(doc.get_array().get(arr));
-  int64_t x;
-  ASSERT_SUCCESS(arr.at_path("$[3].foo.a[1]").get(x));
-  ASSERT_EQUAL(x, 20);
-  TEST_SUCCEED();
-}
-struct car_type {
-  std::string make;
-  std::string model;
-  uint64_t year;
-  std::vector<double> tire_pressure;
-  car_type(std::string_view _make, std::string_view _model, uint64_t _year,
-           std::vector<double> &&_tire_pressure)
-      : make{_make}, model{_model}, year(_year), tire_pressure(_tire_pressure) {
-  }
-};
-
-bool json_path_invalidation() {
-  TEST_START();
-  auto cars_json = R"( [
-        { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
-        { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
-        { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
-        ] )"_padded;
-
-  dom::parser parser;
-  dom::element cars;
-  std::vector<double> measured;
-  ASSERT_SUCCESS(parser.parse(cars_json).get(cars));
-  std::vector<car_type> content;
-  for (int i = 0; i < 3; i++) {
-    dom::object obj;
-    std::string json_path =
-        std::string("$[") + std::to_string(i) + std::string("]");
-    // Each successive at_path call invalidates
-    // previously parsed values, strings, objects and array.
-    ASSERT_SUCCESS(cars.at_path(json_path).get(obj));
-    // We materialize the object.
-    std::string_view make;
-    ASSERT_SUCCESS(obj["make"].get(make));
-    std::string_view model;
-    ASSERT_SUCCESS(obj["model"].get(model));
-    uint64_t year;
-    ASSERT_SUCCESS(obj["year"].get(year));
-    // We materialize the array.
-    dom::array arr;
-    ASSERT_SUCCESS(obj["tire_pressure"].get(arr));
-    std::vector<double> values;
-    for (auto x : arr) {
-      double value_double;
-      ASSERT_SUCCESS(x.get(value_double));
-      values.push_back(value_double);
-    }
-    content.emplace_back(make, model, year, std::move(values));
-  }
-  std::string expected[] = {"Toyota", "Kia", "Toyota"};
-  int i = 0;
-  for (car_type c : content) {
-    std::cout << c.make << " " << c.model << " " << c.year << "\n";
-    ASSERT_EQUAL(expected[i++], c.make);
-  }
-  TEST_SUCCEED();
-}
-// for 0.5 version and following (standard compliant)
-bool modern_support() {
-#if SIMDJSON_EXCEPTIONS
-  std::cout << "modern test" << std::endl;
-  auto example_json = R"({"key": "value", "array": [0, 1, 2]})"_padded;
-  dom::parser parser;
-  dom::element example = parser.parse(example_json);
-  std::string_view value_str = example.at_path("$.key");
-  ASSERT_EQUAL(value_str, "value");
-  int64_t array0 = example.at_path("$.array[0]");
-  ASSERT_EQUAL(array0, 0);
-  array0 = example.at_path("$.array").at_path("$[0]");
-  ASSERT_EQUAL(array0, 0);
-  ASSERT_ERROR(example.at_path("$.no_such_key").error(), NO_SUCH_FIELD);
-  ASSERT_ERROR(example.at_path("$.array[9]").error(), INDEX_OUT_OF_BOUNDS);
-  ASSERT_ERROR(example.at_path("$.array.not_a_num").error(), INCORRECT_TYPE);
-  ASSERT_ERROR(example.at_path("$.array.").error(), INVALID_JSON_POINTER);
-#endif
-  return true;
-}
-
-int main() {
-  if (true && demo() && modern_support() &&
-      run_success_test(TEST_RFC_JSON, "$.foo", "[\"bar\",\"baz\"]") &&
-      run_success_test(TEST_RFC_JSON, "$.foo[0]", "\"bar\"") &&
-      run_success_test(TEST_RFC_JSON, "$.", "0") &&
-      run_success_test(TEST_RFC_JSON, "$.a/b", "1") &&
-      run_success_test(TEST_RFC_JSON, "$.c%d", "2") &&
-      run_success_test(TEST_RFC_JSON, "$.e^f", "3") &&
-      run_success_test(TEST_RFC_JSON, "$.g|h", "4") &&
-      run_success_test(TEST_RFC_JSON, "$.i\\j", "5") &&
-      run_success_test(TEST_RFC_JSON, "$.k\"l", "6") &&
-      run_success_test(TEST_RFC_JSON, "$. ", "7") &&
-      run_success_test(TEST_RFC_JSON, "$.m~n", "8") &&
-      run_success_test(TEST_JSON, "$./~01abc",
-                       R"([0,{"\\\" 0":["value0","value1"]}])") &&
-      run_success_test(TEST_JSON, "$./~01abc[1]",
-                       R"({"\\\" 0":["value0","value1"]})") &&
-      run_success_test(TEST_JSON, "$./~01abc[1].\\\" 0",
-                       R"(["value0","value1"])") &&
-      run_success_test(TEST_JSON, "$.arr", R"([])") // get array
-      &&
-      run_failure_test(TEST_JSON, R"($./~01abc[1].\\\" 0[2])", NO_SUCH_FIELD) &&
-      run_failure_test(TEST_JSON, "$.arr[0]", INDEX_OUT_OF_BOUNDS) &&
-      run_failure_test(TEST_JSON, "/~01abc", INVALID_JSON_POINTER) &&
-      run_failure_test(TEST_JSON, ".~1abc", NO_SUCH_FIELD) &&
-      run_failure_test(TEST_JSON, "./~01abc.01", INVALID_JSON_POINTER) &&
-      run_failure_test(TEST_JSON, "./~01abc.", INVALID_JSON_POINTER) &&
-      run_failure_test(TEST_JSON, "./~01abc.-", INDEX_OUT_OF_BOUNDS)) {
-    std::cout << "Success!" << std::endl;
-    return 0;
-  } else {
-    std::cerr << "Failed!" << std::endl;
-    return 1;
-  }
-}
@@ -461,44 +461,7 @@ void parse_documentation_lowlevel() {
  (void)element;
 }

-
-void jsondollar() {
-  dom::parser parser;
-  auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
-  dom::element doc;
-  auto error = parser.parse(json).get(doc);
-  if(error) { exit(-1); }
-  dom::object obj;
-  error = doc.get_object().get(obj);
-  if(error) { exit(-1); }
-  int64_t x = 0; // initialization to silence unwarranted compiler warning
-  error = obj.at_path("$[3].foo.a[1]").get(x);
-  if(error) { exit(-1); }
-  if(x != 20) { exit(-1); }
-  x = obj.at_path("$.d.foo2.a.2");
-  if(x != 30) { exit(-1); }
-  if(error) { exit(-1); }
-}
-
-void jsonpath() {
-  auto cars_json = R"( [
-    { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
-    { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
-    { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
-  ] )"_padded;
-  dom::parser parser;
-  dom::element doc;
-  auto error = parser.parse(cars_json).get(doc);
-  if(error) { exit(-1); }
-  double p = 0.0; // initialization to silence unwarranted compiler warning
-  error = doc.at_path("[0].tire_pressure[1]").get(p);
-  if(error) { exit(-1); }
-  if(p != 39.9) { exit(-1); }
-}
-
 int main() {
-  jsonpath();
-  jsondollar();
  basics_dom_1();
  basics_dom_2();
  basics_dom_3();
@@ -21,24 +21,8 @@ long page_size() {
 // Returns true if the buffer + len + simdjson::SIMDJSON_PADDING crosses the
 // page boundary.
 bool need_allocation(const char *buf, size_t len) {
-  return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size())
-    + simdjson::SIMDJSON_PADDING > static_cast<uintptr_t>(page_size()));
-}
-
-bool check_need_allocation() {
-  long ps = page_size();
-  std::vector<std::tuple<uintptr_t,size_t,bool>> test_cases = {
-    {2*ps, 5, false}, {2*ps, ps, true}, {2*ps, 100, false},
-  };
-  for(auto t : test_cases) {
-    uintptr_t buf = std::get<0>(t);
-    size_t len = std::get<1>(t);
-    bool expected = std::get<2>(t);
-    if(need_allocation(reinterpret_cast<const char *>(buf), len) != expected) {
-      return false;
-    }
-  }
-  return true;
+  return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size()) <
+          simdjson::SIMDJSON_PADDING);
 }

 simdjson::padded_string_view
@@ -55,10 +39,6 @@ get_padded_string_view(const char *buf, size_t len,

 int main() {
  printf("page_size: %ld\n", page_size());
-  if(!check_need_allocation()) {
-    printf("Bug in the need_allocation function.\n");
-    return EXIT_FAILURE;
-  }
  const char *jsonpoiner = R"(
        {
            "key": "value"
@@ -346,54 +346,6 @@ namespace json_path_tests {
        TEST_SUCCEED();
    }

-    bool many_json_paths_with_prefix() {
-        TEST_START();
-        // object
-        {
-            auto cfoofoo2 = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
-            ondemand::parser parser;
-            ondemand::document doc;
-            ASSERT_SUCCESS(parser.iterate(cfoofoo2).get(doc));
-            ondemand::object obj;
-            ASSERT_SUCCESS(doc.get_object().get(obj));
-            int64_t x;
-            ASSERT_SUCCESS(obj.at_path("$.c.foo.a[1]").get(x));
-            ASSERT_EQUAL(x, 20);
-            ASSERT_SUCCESS(obj.at_path("$.d.foo2.a.2").get(x));
-            ASSERT_EQUAL(x, 30);
-            ASSERT_SUCCESS(obj.at_path("$.e").get(x));
-            ASSERT_EQUAL(x, 120);
-        }
-        // array
-        {
-            auto cfoofoo2 = R"( [ 111, 2, 3, { "foo": { "a": [ 10, 20, 33 ] }}, { "foo2": { "a": [ 10, 20, 30 ] }}, 1001 ])"_padded;
-            ondemand::parser parser;
-            ondemand::document doc;
-            ASSERT_SUCCESS(parser.iterate(cfoofoo2).get(doc));
-            ondemand::array arr;
-            ASSERT_SUCCESS(doc.get_array().get(arr));
-            int64_t x;
-            ASSERT_SUCCESS(arr.at_path("$[3].foo.a[1]").get(x));
-            ASSERT_EQUAL(x, 20);
-        }
-        // onject array
-        {
-            auto dogcatpotato = R"( { "dog" : [1,2,3], "cat" : [5, 6, 7], "potato" : [1234]})"_padded;
-
-            ondemand::parser parser;
-            ondemand::document doc;
-            ASSERT_SUCCESS(parser.iterate(dogcatpotato).get(doc));
-            ondemand::object obj;
-            ASSERT_SUCCESS(doc.get_object().get(obj));
-            int64_t x;
-            ASSERT_SUCCESS(obj.at_path("$.dog[1]").get(x));
-            ASSERT_EQUAL(x, 2);
-            ASSERT_SUCCESS(obj.at_path("$.potato[0]").get(x));
-            ASSERT_EQUAL(x, 1234);
-        }
-        TEST_SUCCEED();
-    }
-
 #if SIMDJSON_EXCEPTIONS
    bool json_path_invalidation_exceptions() {
        TEST_START();
@@ -440,7 +392,6 @@ namespace json_path_tests {
                many_json_paths_array() &&
                many_json_paths_object() &&
                many_json_paths_object_array() &&
-                many_json_paths_with_prefix() &&
                run_broken_tests() &&
                json_path_invalidation() &&
                demo_test() &&
@@ -236,19 +236,6 @@ bool gen_raw2() {
  TEST_SUCCEED();
 }

-bool jsondollar() {
-  TEST_START();
-  auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
-  ondemand::parser parser;
-  ondemand::document doc = parser.iterate(json);
-  ondemand::object obj = doc.get_object();
-  int64_t x = obj.at_path("$.c.foo.a[1]"); // 20
-  ASSERT_EQUAL(x, 20);
-  x = obj.at_path("$.d.foo2.a.2"); // 30
-  ASSERT_EQUAL(x, 30);
-  TEST_SUCCEED();
-}
-
 bool gen_raw3() {
  TEST_START();
  simdjson::ondemand::parser parser;
@@ -1904,7 +1891,6 @@ bool run() {
 #if SIMDJSON_CPLUSPLUS17
    && big_int_array()
 #endif // SIMDJSON_CPLUSPLUS17
-    && jsondollar()
    && big_int_array_as_double()
    && key_raw_json_token()
    && to_optional()
@@ -369,24 +369,15 @@ namespace scalar_tests {
    ondemand::parser parser;
    ondemand::document doc;
    ASSERT_SUCCESS(parser.iterate(json).get(doc));
-    ASSERT_ERROR(doc.is_null(), INCORRECT_TYPE);
-    TEST_SUCCEED();
-  }
-
-  bool nul() {
-    TEST_START();
-    auto json = R"( nul )"_padded;
-    ondemand::parser parser;
-    ondemand::document doc;
-    ASSERT_SUCCESS(parser.iterate(json).get(doc));
-    ASSERT_ERROR(doc.is_null(), INCORRECT_TYPE);
+    bool x;
+    ASSERT_SUCCESS(doc.is_null().get(x));
+    ASSERT_TRUE(!x);
    TEST_SUCCEED();
  }

  bool run() {
    return
           nully() &&
-           nul() &&
           string_with_trailing() &&
           uint64_with_trailing() &&
           int64_with_trailing() &&