simdjson 0.1.0

data/vendor/simdjson/include/simdjson/stage1_find_marks_macros.h

@@ -0,0 +1,239 @@
+#ifndef SIMDJSON_STAGE1_FIND_MARKS_MACROS_H
+#define SIMDJSON_STAGE1_FIND_MARKS_MACROS_H
+
+// return a bitvector indicating where we have characters that end an odd-length
+// sequence of backslashes (and thus change the behavior of the next character
+// to follow). A even-length sequence of backslashes, and, for that matter, the
+// largest even-length prefix of our odd-length sequence of backslashes, simply
+// modify the behavior of the backslashes themselves.
+// We also update the prev_iter_ends_odd_backslash reference parameter to
+// indicate whether we end an iteration on an odd-length sequence of
+// backslashes, which modifies our subsequent search for odd-length
+// sequences of backslashes in an obvious way.
+// We need to compile that code for multiple architectures. However, target
+// attributes can be used only once by function definition. Huge macro seemed
+// better than huge code duplication. uint64_t
+// FIND_ODD_BACKSLASH_SEQUENCES(Architecture T, simd_input<T> in, uint64_t
+// &prev_iter_ends_odd_backslash)
+#define FIND_ODD_BACKSLASH_SEQUENCES(T, in, prev_iter_ends_odd_backslash)      \
+  {                                                                            \
+    const uint64_t even_bits = 0x5555555555555555ULL;                          \
+    const uint64_t odd_bits = ~even_bits;                                      \
+    uint64_t bs_bits = cmp_mask_against_input<T>(in, '\\');                    \
+    uint64_t start_edges = bs_bits & ~(bs_bits << 1);                          \
+    /* flip lowest if we have an odd-length run at the end of the prior        \
+     * iteration */                                                            \
+    uint64_t even_start_mask = even_bits ^ prev_iter_ends_odd_backslash;       \
+    uint64_t even_starts = start_edges & even_start_mask;                      \
+    uint64_t odd_starts = start_edges & ~even_start_mask;                      \
+    uint64_t even_carries = bs_bits + even_starts;                             \
+                                                                               \
+    uint64_t odd_carries;                                                      \
+    /* must record the carry-out of our odd-carries out of bit 63; this        \
+     * indicates whether the sense of any edge going to the next iteration     \
+     * should be flipped */                                                    \
+    bool iter_ends_odd_backslash =                                             \
+        add_overflow(bs_bits, odd_starts, &odd_carries);                       \
+                                                                               \
+    odd_carries |= prev_iter_ends_odd_backslash; /* push in bit zero as a      \
+                                                  * potential end if we had an \
+                                                  * odd-numbered run at the    \
+                                                  * end of the previous        \
+                                                  * iteration */               \
+    prev_iter_ends_odd_backslash = iter_ends_odd_backslash ? 0x1ULL : 0x0ULL;  \
+    uint64_t even_carry_ends = even_carries & ~bs_bits;                        \
+    uint64_t odd_carry_ends = odd_carries & ~bs_bits;                          \
+    uint64_t even_start_odd_end = even_carry_ends & odd_bits;                  \
+    uint64_t odd_start_even_end = odd_carry_ends & even_bits;                  \
+    uint64_t odd_ends = even_start_odd_end | odd_start_even_end;               \
+    return odd_ends;                                                           \
+  }
+
+// return both the quote mask (which is a half-open mask that covers the first
+// quote
+// in an unescaped quote pair and everything in the quote pair) and the quote
+// bits, which are the simple
+// unescaped quoted bits. We also update the prev_iter_inside_quote value to
+// tell the next iteration
+// whether we finished the final iteration inside a quote pair; if so, this
+// inverts our behavior of
+// whether we're inside quotes for the next iteration.
+// Note that we don't do any error checking to see if we have backslash
+// sequences outside quotes; these
+// backslash sequences (of any length) will be detected elsewhere.
+// We need to compile that code for multiple architectures. However, target
+// attributes can be used only once by function definition. Huge macro seemed
+// better than huge code duplication. uint64_t
+// FIND_QUOTE_MASK_AND_BITS(Architecture T, simd_input<T> in, uint64_t odd_ends,
+//    uint64_t &prev_iter_inside_quote, uint64_t &quote_bits, uint64_t
+//    &error_mask)
+#define FIND_QUOTE_MASK_AND_BITS(T, in, odd_ends, prev_iter_inside_quote,      \
+                                 quote_bits, error_mask)                       \
+  {                                                                            \
+    quote_bits = cmp_mask_against_input<T>(in, '"');                           \
+    quote_bits = quote_bits & ~odd_ends;                                       \
+    uint64_t quote_mask = compute_quote_mask<T>(quote_bits);                   \
+    quote_mask ^= prev_iter_inside_quote;                                      \
+    /* All Unicode characters may be placed within the                         \
+     * quotation marks, except for the characters that MUST be escaped:        \
+     * quotation mark, reverse solidus, and the control characters (U+0000     \
+     * through U+001F).                                                        \
+     * https://tools.ietf.org/html/rfc8259 */                                  \
+    uint64_t unescaped = unsigned_lteq_against_input<T>(in, 0x1F);             \
+    error_mask |= quote_mask & unescaped;                                      \
+    /* right shift of a signed value expected to be well-defined and standard  \
+     * compliant as of C++20,                                                  \
+     * John Regher from Utah U. says this is fine code */                      \
+    prev_iter_inside_quote =                                                   \
+        static_cast<uint64_t>(static_cast<int64_t>(quote_mask) >> 63);         \
+    return quote_mask;                                                         \
+  }
+
+// Find structural bits in a 64-byte chunk.
+// We need to compile that code for multiple architectures. However, target
+// attributes can be used only once by function definition. Huge macro seemed
+// better than huge code duplication. void FIND_STRUCTURAL_BITS_64(
+//                              Architecture T,
+//                              const uint8_t *buf,
+//                              size_t idx,
+//                              uint32_t *base_ptr,
+//                              uint32_t &base,
+//                              uint64_t &prev_iter_ends_odd_backslash,
+//                              uint64_t &prev_iter_inside_quote,
+//                              uint64_t &prev_iter_ends_pseudo_pred,
+//                              uint64_t &structurals,
+//                              uint64_t &error_mask,
+//                              utf8_checking_state<T> &utf8_state, flatten
+//                              function)
+#define FIND_STRUCTURAL_BITS_64(                                               \
+    T, buf, idx, base_ptr, base, prev_iter_ends_odd_backslash,                 \
+    prev_iter_inside_quote, prev_iter_ends_pseudo_pred, structurals,           \
+    error_mask, utf8_state, flat)                                              \
+  {                                                                            \
+    simd_input<T> in = fill_input<T>(buf);                                     \
+    check_utf8<T>(in, utf8_state);                                             \
+    /* detect odd sequences of backslashes */                                  \
+    uint64_t odd_ends =                                                        \
+        find_odd_backslash_sequences<T>(in, prev_iter_ends_odd_backslash);     \
+                                                                               \
+    /* detect insides of quote pairs ("quote_mask") and also our quote_bits    \
+     * themselves */                                                           \
+    uint64_t quote_bits;                                                       \
+    uint64_t quote_mask = find_quote_mask_and_bits<T>(                         \
+        in, odd_ends, prev_iter_inside_quote, quote_bits, error_mask);         \
+                                                                               \
+    /* take the previous iterations structural bits, not our current           \
+     * iteration,                                                              \
+     * and flatten */                                                          \
+    flat(base_ptr, base, idx, structurals);                                    \
+                                                                               \
+    uint64_t whitespace;                                                       \
+    find_whitespace_and_structurals<T>(in, whitespace, structurals);           \
+                                                                               \
+    /* fixup structurals to reflect quotes and add pseudo-structural           \
+     * characters */                                                           \
+    structurals =                                                              \
+        finalize_structurals(structurals, whitespace, quote_mask, quote_bits,  \
+                             prev_iter_ends_pseudo_pred);                      \
+  }
+
+// We need to compile that code for multiple architectures. However, target
+// attributes can be used only once by function definition. Huge macro seemed
+// better than huge code duplication. ErrorValues
+// FIND_STRUCTURAL_BITS(Architecture T, const uint8_t *buf, size_t len,
+// ParsedJson &pj, flatten function)
+#define FIND_STRUCTURAL_BITS(T, buf, len, pj, flat)                            \
+  {                                                                            \
+    if (len > pj.byte_capacity) {                                              \
+      std::cerr << "Your ParsedJson object only supports documents up to "     \
+                << pj.byte_capacity << " bytes but you are trying to process " \
+                << len << " bytes" << std::endl;                               \
+      return simdjson::CAPACITY;                                               \
+    }                                                                          \
+    uint32_t *base_ptr = pj.structural_indexes;                                \
+    uint32_t base = 0;                                                         \
+    utf8_checking_state<T> utf8_state;                                         \
+                                                                               \
+    /* we have padded the input out to 64 byte multiple with the remainder     \
+     * being zeros persistent state across loop does the last iteration end    \
+     * with an odd-length sequence of backslashes? */                          \
+                                                                               \
+    /* either 0 or 1, but a 64-bit value */                                    \
+    uint64_t prev_iter_ends_odd_backslash = 0ULL;                              \
+    /* does the previous iteration end inside a double-quote pair? */          \
+    uint64_t prev_iter_inside_quote =                                          \
+        0ULL; /* either all zeros or all ones                                  \
+               * does the previous iteration end on something that is a        \
+               * predecessor of a pseudo-structural character - i.e.           \
+               * whitespace or a structural character effectively the very     \
+               * first char is considered to follow "whitespace" for the       \
+               * purposes of pseudo-structural character detection so we       \
+               * initialize to 1 */                                            \
+    uint64_t prev_iter_ends_pseudo_pred = 1ULL;                                \
+                                                                               \
+    /* structurals are persistent state across loop as we flatten them on the  \
+     * subsequent iteration into our array pointed to be base_ptr.             \
+     * This is harmless on the first iteration as structurals==0               \
+     * and is done for performance reasons; we can hide some of the latency of \
+     * the                                                                     \
+     * expensive carryless multiply in the previous step with this work */     \
+    uint64_t structurals = 0;                                                  \
+                                                                               \
+    size_t lenminus64 = len < 64 ? 0 : len - 64;                               \
+    size_t idx = 0;                                                            \
+    uint64_t error_mask = 0; /* for unescaped characters within strings (ASCII \
+                                code points < 0x20) */                         \
+                                                                               \
+    for (; idx < lenminus64; idx += 64) {                                      \
+      FIND_STRUCTURAL_BITS_64(                                                 \
+          T, &buf[idx], idx, base_ptr, base, prev_iter_ends_odd_backslash,     \
+          prev_iter_inside_quote, prev_iter_ends_pseudo_pred, structurals,     \
+          error_mask, utf8_state, flat);                                       \
+    }                                                                          \
+    /* If we have a final chunk of less than 64 bytes, pad it to 64 with       \
+     * spaces  before processing it (otherwise, we risk invalidating the UTF-8 \
+     * checks). */                                                             \
+    if (idx < len) {                                                           \
+      uint8_t tmp_buf[64];                                                     \
+      memset(tmp_buf, 0x20, 64);                                               \
+      memcpy(tmp_buf, buf + idx, len - idx);                                   \
+      FIND_STRUCTURAL_BITS_64(                                                 \
+          T, &tmp_buf[0], idx, base_ptr, base, prev_iter_ends_odd_backslash,   \
+          prev_iter_inside_quote, prev_iter_ends_pseudo_pred, structurals,     \
+          error_mask, utf8_state, flat);                                       \
+      idx += 64;                                                               \
+    }                                                                          \
+                                                                               \
+    /* is last string quote closed? */                                         \
+    if (prev_iter_inside_quote) {                                              \
+      return simdjson::UNCLOSED_STRING;                                        \
+    }                                                                          \
+                                                                               \
+    /* finally, flatten out the remaining structurals from the last iteration  \
+     */                                                                        \
+    flat(base_ptr, base, idx, structurals);                                    \
+                                                                               \
+    pj.n_structural_indexes = base;                                            \
+    /* a valid JSON file cannot have zero structural indexes - we should have  \
+     * found something */                                                      \
+    if (pj.n_structural_indexes == 0u) {                                       \
+      return simdjson::EMPTY;                                                  \
+    }                                                                          \
+    if (base_ptr[pj.n_structural_indexes - 1] > len) {                         \
+      return simdjson::UNEXPECTED_ERROR;                                       \
+    }                                                                          \
+    if (len != base_ptr[pj.n_structural_indexes - 1]) {                        \
+      /* the string might not be NULL terminated, but we add a virtual NULL    \
+       * ending                                                                \
+       * character. */                                                         \
+      base_ptr[pj.n_structural_indexes++] = len;                               \
+    }                                                                          \
+    /* make it safe to dereference one beyond this array */                    \
+    base_ptr[pj.n_structural_indexes] = 0;                                     \
+    if (error_mask) {                                                          \
+      return simdjson::UNESCAPED_CHARS;                                        \
+    }                                                                          \
+    return check_utf8_errors<T>(utf8_state);                                   \
+  }
+
+#endif // SIMDJSON_STAGE1_FIND_MARKS_MACROS_H

data/vendor/simdjson/include/simdjson/stage1_find_marks_westmere.h

@@ -0,0 +1,194 @@
+#ifndef SIMDJSON_STAGE1_FIND_MARKS_WESTMERE_H
+#define SIMDJSON_STAGE1_FIND_MARKS_WESTMERE_H
+
+#include "simdjson/simdutf8check_westmere.h"
+#include "simdjson/stage1_find_marks.h"
+#include "simdjson/stage1_find_marks_flatten.h"
+#include "simdjson/stage1_find_marks_macros.h"
+
+#ifdef IS_X86_64
+
+TARGET_WESTMERE
+namespace simdjson {
+template <> struct simd_input<Architecture::WESTMERE> {
+  __m128i v0;
+  __m128i v1;
+  __m128i v2;
+  __m128i v3;
+};
+
+template <>
+really_inline simd_input<Architecture::WESTMERE>
+fill_input<Architecture::WESTMERE>(const uint8_t *ptr) {
+  struct simd_input<Architecture::WESTMERE> in;
+  in.v0 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(ptr + 0));
+  in.v1 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(ptr + 16));
+  in.v2 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(ptr + 32));
+  in.v3 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(ptr + 48));
+  return in;
+}
+
+template <>
+really_inline uint64_t
+compute_quote_mask<Architecture::WESTMERE>(uint64_t quote_bits) {
+  return _mm_cvtsi128_si64(_mm_clmulepi64_si128(
+      _mm_set_epi64x(0ULL, quote_bits), _mm_set1_epi8(0xFFu), 0));
+}
+
+template <> struct utf8_checking_state<Architecture::WESTMERE> {
+  __m128i has_error = _mm_setzero_si128();
+  processed_utf_bytes previous{
+      _mm_setzero_si128(), // raw_bytes
+      _mm_setzero_si128(), // high_nibbles
+      _mm_setzero_si128()  // carried_continuations
+  };
+};
+
+template <>
+really_inline void check_utf8<Architecture::WESTMERE>(
+    simd_input<Architecture::WESTMERE> in,
+    utf8_checking_state<Architecture::WESTMERE> &state) {
+  __m128i high_bit = _mm_set1_epi8(0x80u);
+  if ((_mm_testz_si128(_mm_or_si128(in.v0, in.v1), high_bit)) == 1) {
+    // it is ascii, we just check continuation
+    state.has_error =
+        _mm_or_si128(_mm_cmpgt_epi8(state.previous.carried_continuations,
+                                    _mm_setr_epi8(9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+                                                  9, 9, 9, 9, 9, 1)),
+                     state.has_error);
+  } else {
+    // it is not ascii so we have to do heavy work
+    state.previous =
+        check_utf8_bytes(in.v0, &(state.previous), &(state.has_error));
+    state.previous =
+        check_utf8_bytes(in.v1, &(state.previous), &(state.has_error));
+  }
+
+  if ((_mm_testz_si128(_mm_or_si128(in.v2, in.v3), high_bit)) == 1) {
+    // it is ascii, we just check continuation
+    state.has_error =
+        _mm_or_si128(_mm_cmpgt_epi8(state.previous.carried_continuations,
+                                    _mm_setr_epi8(9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
+                                                  9, 9, 9, 9, 9, 1)),
+                     state.has_error);
+  } else {
+    // it is not ascii so we have to do heavy work
+    state.previous =
+        check_utf8_bytes(in.v2, &(state.previous), &(state.has_error));
+    state.previous =
+        check_utf8_bytes(in.v3, &(state.previous), &(state.has_error));
+  }
+}
+
+template <>
+really_inline ErrorValues check_utf8_errors<Architecture::WESTMERE>(
+    utf8_checking_state<Architecture::WESTMERE> &state) {
+  return _mm_testz_si128(state.has_error, state.has_error) == 0
+             ? simdjson::UTF8_ERROR
+             : simdjson::SUCCESS;
+}
+
+template <>
+really_inline uint64_t cmp_mask_against_input<Architecture::WESTMERE>(
+    simd_input<Architecture::WESTMERE> in, uint8_t m) {
+  const __m128i mask = _mm_set1_epi8(m);
+  __m128i cmp_res_0 = _mm_cmpeq_epi8(in.v0, mask);
+  uint64_t res_0 = _mm_movemask_epi8(cmp_res_0);
+  __m128i cmp_res_1 = _mm_cmpeq_epi8(in.v1, mask);
+  uint64_t res_1 = _mm_movemask_epi8(cmp_res_1);
+  __m128i cmp_res_2 = _mm_cmpeq_epi8(in.v2, mask);
+  uint64_t res_2 = _mm_movemask_epi8(cmp_res_2);
+  __m128i cmp_res_3 = _mm_cmpeq_epi8(in.v3, mask);
+  uint64_t res_3 = _mm_movemask_epi8(cmp_res_3);
+  return res_0 | (res_1 << 16) | (res_2 << 32) | (res_3 << 48);
+}
+
+template <>
+really_inline uint64_t unsigned_lteq_against_input<Architecture::WESTMERE>(
+    simd_input<Architecture::WESTMERE> in, uint8_t m) {
+  const __m128i maxval = _mm_set1_epi8(m);
+  __m128i cmp_res_0 = _mm_cmpeq_epi8(_mm_max_epu8(maxval, in.v0), maxval);
+  uint64_t res_0 = _mm_movemask_epi8(cmp_res_0);
+  __m128i cmp_res_1 = _mm_cmpeq_epi8(_mm_max_epu8(maxval, in.v1), maxval);
+  uint64_t res_1 = _mm_movemask_epi8(cmp_res_1);
+  __m128i cmp_res_2 = _mm_cmpeq_epi8(_mm_max_epu8(maxval, in.v2), maxval);
+  uint64_t res_2 = _mm_movemask_epi8(cmp_res_2);
+  __m128i cmp_res_3 = _mm_cmpeq_epi8(_mm_max_epu8(maxval, in.v3), maxval);
+  uint64_t res_3 = _mm_movemask_epi8(cmp_res_3);
+  return res_0 | (res_1 << 16) | (res_2 << 32) | (res_3 << 48);
+}
+
+template <>
+really_inline uint64_t find_odd_backslash_sequences<Architecture::WESTMERE>(
+    simd_input<Architecture::WESTMERE> in,
+    uint64_t &prev_iter_ends_odd_backslash) {
+  FIND_ODD_BACKSLASH_SEQUENCES(Architecture::WESTMERE, in,
+                               prev_iter_ends_odd_backslash);
+}
+
+template <>
+really_inline uint64_t find_quote_mask_and_bits<Architecture::WESTMERE>(
+    simd_input<Architecture::WESTMERE> in, uint64_t odd_ends,
+    uint64_t &prev_iter_inside_quote, uint64_t &quote_bits,
+    uint64_t &error_mask) {
+  FIND_QUOTE_MASK_AND_BITS(Architecture::WESTMERE, in, odd_ends,
+                           prev_iter_inside_quote, quote_bits, error_mask)
+}
+
+template <>
+really_inline void find_whitespace_and_structurals<Architecture::WESTMERE>(
+    simd_input<Architecture::WESTMERE> in, uint64_t &whitespace,
+    uint64_t &structurals) {
+  const __m128i structural_table =
+      _mm_setr_epi8(44, 125, 0, 0, 0xc0u, 0, 0, 0, 0, 0, 0, 0, 0, 0, 58, 123);
+  const __m128i white_table = _mm_setr_epi8(32, 100, 100, 100, 17, 100, 113, 2,
+                                            100, 9, 10, 112, 100, 13, 100, 100);
+  const __m128i struct_offset = _mm_set1_epi8(0xd4u);
+  const __m128i struct_mask = _mm_set1_epi8(32);
+
+  __m128i white0 = _mm_cmpeq_epi8(in.v0, _mm_shuffle_epi8(white_table, in.v0));
+  __m128i white1 = _mm_cmpeq_epi8(in.v1, _mm_shuffle_epi8(white_table, in.v1));
+  __m128i white2 = _mm_cmpeq_epi8(in.v2, _mm_shuffle_epi8(white_table, in.v2));
+  __m128i white3 = _mm_cmpeq_epi8(in.v3, _mm_shuffle_epi8(white_table, in.v3));
+  uint64_t ws_res_0 = _mm_movemask_epi8(white0);
+  uint64_t ws_res_1 = _mm_movemask_epi8(white1);
+  uint64_t ws_res_2 = _mm_movemask_epi8(white2);
+  uint64_t ws_res_3 = _mm_movemask_epi8(white3);
+
+  whitespace =
+      (ws_res_0 | (ws_res_1 << 16) | (ws_res_2 << 32) | (ws_res_3 << 48));
+
+  __m128i struct1_r1 = _mm_add_epi8(struct_offset, in.v0);
+  __m128i struct2_r1 = _mm_add_epi8(struct_offset, in.v1);
+  __m128i struct3_r1 = _mm_add_epi8(struct_offset, in.v2);
+  __m128i struct4_r1 = _mm_add_epi8(struct_offset, in.v3);
+
+  __m128i struct1_r2 = _mm_or_si128(in.v0, struct_mask);
+  __m128i struct2_r2 = _mm_or_si128(in.v1, struct_mask);
+  __m128i struct3_r2 = _mm_or_si128(in.v2, struct_mask);
+  __m128i struct4_r2 = _mm_or_si128(in.v3, struct_mask);
+
+  __m128i struct1_r3 = _mm_shuffle_epi8(structural_table, struct1_r1);
+  __m128i struct2_r3 = _mm_shuffle_epi8(structural_table, struct2_r1);
+  __m128i struct3_r3 = _mm_shuffle_epi8(structural_table, struct3_r1);
+  __m128i struct4_r3 = _mm_shuffle_epi8(structural_table, struct4_r1);
+
+  __m128i struct1 = _mm_cmpeq_epi8(struct1_r2, struct1_r3);
+  __m128i struct2 = _mm_cmpeq_epi8(struct2_r2, struct2_r3);
+  __m128i struct3 = _mm_cmpeq_epi8(struct3_r2, struct3_r3);
+  __m128i struct4 = _mm_cmpeq_epi8(struct4_r2, struct4_r3);
+
+  uint64_t structural_res_0 = _mm_movemask_epi8(struct1);
+  uint64_t structural_res_1 = _mm_movemask_epi8(struct2);
+  uint64_t structural_res_2 = _mm_movemask_epi8(struct3);
+  uint64_t structural_res_3 = _mm_movemask_epi8(struct4);
+
+  structurals = (structural_res_0 | (structural_res_1 << 16) |
+                 (structural_res_2 << 32) | (structural_res_3 << 48));
+}
+
+} // namespace simdjson
+UNTARGET_REGION
+
+#endif // IS_X86_64
+#endif // SIMDJSON_STAGE1_FIND_MARKS_WESTMERE_H

data/vendor/simdjson/include/simdjson/stage2_build_tape.h

@@ -0,0 +1,85 @@
+#ifndef SIMDJSON_STAGE2_BUILD_TAPE_H
+#define SIMDJSON_STAGE2_BUILD_TAPE_H
+
+#include <cassert>
+#include <cstring>
+#include <iostream>
+
+#include "simdjson/common_defs.h"
+#include "simdjson/jsoncharutils.h"
+#include "simdjson/numberparsing.h"
+#include "simdjson/parsedjson.h"
+#include "simdjson/simdjson.h"
+#include "simdjson/stringparsing.h"
+
+namespace simdjson {
+void init_state_machine();
+
+WARN_UNUSED
+really_inline bool is_valid_true_atom(const uint8_t *loc) {
+  uint64_t tv = *reinterpret_cast<const uint64_t *>("true    ");
+  uint64_t mask4 = 0x00000000ffffffff;
+  uint32_t error = 0;
+  uint64_t
+      locval; // we want to avoid unaligned 64-bit loads (undefined in C/C++)
+  // this can read up to 7 bytes beyond the buffer size, but we require
+  // SIMDJSON_PADDING of padding
+  static_assert(sizeof(uint64_t) - 1 <= SIMDJSON_PADDING);
+  std::memcpy(&locval, loc, sizeof(uint64_t));
+  error = (locval & mask4) ^ tv;
+  error |= is_not_structural_or_whitespace(loc[4]);
+  return error == 0;
+}
+
+WARN_UNUSED
+really_inline bool is_valid_false_atom(const uint8_t *loc) {
+  // We have to use an integer constant because the space in the cast
+  // below would lead to values illegally being qualified
+  // uint64_t fv = *reinterpret_cast<const uint64_t *>("false   ");
+  // using this constant (that is the same false) but nulls out the
+  // unused bits solves that
+  uint64_t fv = 0x00000065736c6166; // takes into account endianness
+  uint64_t mask5 = 0x000000ffffffffff;
+  // we can't use the 32 bit value for checking for errors otherwise
+  // the last character of false (it being 5 byte long!) would be
+  // ignored
+  uint64_t error = 0;
+  uint64_t
+      locval; // we want to avoid unaligned 64-bit loads (undefined in C/C++)
+  // this can read up to 7 bytes beyond the buffer size, but we require
+  // SIMDJSON_PADDING of padding
+  static_assert(sizeof(uint64_t) - 1 <= SIMDJSON_PADDING);
+  std::memcpy(&locval, loc, sizeof(uint64_t));
+  error = (locval & mask5) ^ fv;
+  error |= is_not_structural_or_whitespace(loc[5]);
+  return error == 0;
+}
+
+WARN_UNUSED
+really_inline bool is_valid_null_atom(const uint8_t *loc) {
+  uint64_t nv = *reinterpret_cast<const uint64_t *>("null    ");
+  uint64_t mask4 = 0x00000000ffffffff;
+  uint32_t error = 0;
+  uint64_t
+      locval; // we want to avoid unaligned 64-bit loads (undefined in C/C++)
+  // this can read up to 7 bytes beyond the buffer size, but we require
+  // SIMDJSON_PADDING of padding
+  static_assert(sizeof(uint64_t) - 1 <= SIMDJSON_PADDING);
+  std::memcpy(&locval, loc, sizeof(uint64_t));
+  error = (locval & mask4) ^ nv;
+  error |= is_not_structural_or_whitespace(loc[4]);
+  return error == 0;
+}
+
+template <Architecture T = Architecture::NATIVE>
+WARN_UNUSED ALLOW_SAME_PAGE_BUFFER_OVERRUN_QUALIFIER LENIENT_MEM_SANITIZER int
+unified_machine(const uint8_t *buf, size_t len, ParsedJson &pj);
+
+template <Architecture T = Architecture::NATIVE>
+int unified_machine(const char *buf, size_t len, ParsedJson &pj) {
+  return unified_machine<T>(reinterpret_cast<const uint8_t *>(buf), len, pj);
+}
+
+} // namespace simdjson
+
+#endif

data/vendor/simdjson/include/simdjson/stringparsing.h

@@ -0,0 +1,105 @@
+#ifndef SIMDJSON_STRINGPARSING_H
+#define SIMDJSON_STRINGPARSING_H
+
+#include "simdjson/common_defs.h"
+#include "simdjson/jsoncharutils.h"
+#include "simdjson/parsedjson.h"
+
+#ifdef JSON_TEST_STRINGS
+void found_string(const uint8_t *buf, const uint8_t *parsed_begin,
+                  const uint8_t *parsed_end);
+void found_bad_string(const uint8_t *buf);
+#endif
+
+namespace simdjson {
+// begin copypasta
+// These chars yield themselves: " \ /
+// b -> backspace, f -> formfeed, n -> newline, r -> cr, t -> horizontal tab
+// u not handled in this table as it's complex
+static const uint8_t escape_map[256] = {
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0, // 0x0.
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+    0, 0, 0x22, 0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0x2f,
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0, // 0x4.
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0x5c, 0, 0,    0, // 0x5.
+    0, 0, 0x08, 0, 0,    0, 0x0c, 0, 0, 0, 0, 0, 0,    0, 0x0a, 0, // 0x6.
+    0, 0, 0x0d, 0, 0x09, 0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0, // 0x7.
+
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+    0, 0, 0,    0, 0,    0, 0,    0, 0, 0, 0, 0, 0,    0, 0,    0,
+};
+
+// handle a unicode codepoint
+// write appropriate values into dest
+// src will advance 6 bytes or 12 bytes
+// dest will advance a variable amount (return via pointer)
+// return true if the unicode codepoint was valid
+// We work in little-endian then swap at write time
+WARN_UNUSED
+really_inline bool handle_unicode_codepoint(const uint8_t **src_ptr,
+                                            uint8_t **dst_ptr) {
+  // hex_to_u32_nocheck fills high 16 bits of the return value with 1s if the
+  // conversion isn't valid; we defer the check for this to inside the
+  // multilingual plane check
+  uint32_t code_point = hex_to_u32_nocheck(*src_ptr + 2);
+  *src_ptr += 6;
+  // check for low surrogate for characters outside the Basic
+  // Multilingual Plane.
+  if (code_point >= 0xd800 && code_point < 0xdc00) {
+    if (((*src_ptr)[0] != '\\') || (*src_ptr)[1] != 'u') {
+      return false;
+    }
+    uint32_t code_point_2 = hex_to_u32_nocheck(*src_ptr + 2);
+
+    // if the first code point is invalid we will get here, as we will go past
+    // the check for being outside the Basic Multilingual plane. If we don't
+    // find a \u immediately afterwards we fail out anyhow, but if we do,
+    // this check catches both the case of the first code point being invalid
+    // or the second code point being invalid.
+    if ((code_point | code_point_2) >> 16) {
+      return false;
+    }
+
+    code_point =
+        (((code_point - 0xd800) << 10) | (code_point_2 - 0xdc00)) + 0x10000;
+    *src_ptr += 6;
+  }
+  size_t offset = codepoint_to_utf8(code_point, *dst_ptr);
+  *dst_ptr += offset;
+  return offset > 0;
+}
+
+// Holds backslashes and quotes locations.
+struct parse_string_helper {
+  uint32_t bs_bits;
+  uint32_t quote_bits;
+};
+
+// Finds where the backslashes and quotes are located.
+template <Architecture>
+parse_string_helper find_bs_bits_and_quote_bits(const uint8_t *src,
+                                                uint8_t *dst);
+
+template <Architecture T>
+WARN_UNUSED ALLOW_SAME_PAGE_BUFFER_OVERRUN_QUALIFIER LENIENT_MEM_SANITIZER
+    really_inline bool
+    parse_string(UNUSED const uint8_t *buf, UNUSED size_t len, ParsedJson &pj,
+                 UNUSED const uint32_t depth, UNUSED uint32_t offset);
+
+} // namespace simdjson
+
+/// Now include the specializations:
+#include "simdjson/stringparsing_arm64.h"
+#include "simdjson/stringparsing_haswell.h"
+#include "simdjson/stringparsing_westmere.h"
+
+#endif