simdjson 0.1.0

data/vendor/simdjson/include/simdjson/simdutf8check_arm64.h

@@ -0,0 +1,180 @@
+// From https://github.com/cyb70289/utf8/blob/master/lemire-neon.c
+// Adapted from https://github.com/lemire/fastvalidate-utf-8
+
+#ifndef SIMDJSON_SIMDUTF8CHECK_ARM64_H
+#define SIMDJSON_SIMDUTF8CHECK_ARM64_H
+
+#if defined(_ARM_NEON) || defined(__aarch64__) ||                              \
+    (defined(_MSC_VER) && defined(_M_ARM64))
+
+#include <arm_neon.h>
+#include <cinttypes>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+
+/*
+ * legal utf-8 byte sequence
+ * http://www.unicode.org/versions/Unicode6.0.0/ch03.pdf - page 94
+ *
+ *  Code Points        1st       2s       3s       4s
+ * U+0000..U+007F     00..7F
+ * U+0080..U+07FF     C2..DF   80..BF
+ * U+0800..U+0FFF     E0       A0..BF   80..BF
+ * U+1000..U+CFFF     E1..EC   80..BF   80..BF
+ * U+D000..U+D7FF     ED       80..9F   80..BF
+ * U+E000..U+FFFF     EE..EF   80..BF   80..BF
+ * U+10000..U+3FFFF   F0       90..BF   80..BF   80..BF
+ * U+40000..U+FFFFF   F1..F3   80..BF   80..BF   80..BF
+ * U+100000..U+10FFFF F4       80..8F   80..BF   80..BF
+ *
+ */
+namespace simdjson {
+
+// all byte values must be no larger than 0xF4
+static inline void check_smaller_than_0xF4(int8x16_t current_bytes,
+                                           int8x16_t *has_error) {
+  // unsigned, saturates to 0 below max
+  *has_error = vorrq_s8(
+      *has_error, vreinterpretq_s8_u8(vqsubq_u8(
+                      vreinterpretq_u8_s8(current_bytes), vdupq_n_u8(0xF4))));
+}
+
+static const int8_t _nibbles[] = {
+    1, 1, 1, 1, 1, 1, 1, 1, // 0xxx (ASCII)
+    0, 0, 0, 0,             // 10xx (continuation)
+    2, 2,                   // 110x
+    3,                      // 1110
+    4,                      // 1111, next should be 0 (not checked here)
+};
+
+static inline int8x16_t continuation_lengths(int8x16_t high_nibbles) {
+  return vqtbl1q_s8(vld1q_s8(_nibbles), vreinterpretq_u8_s8(high_nibbles));
+}
+
+static inline int8x16_t carry_continuations(int8x16_t initial_lengths,
+                                            int8x16_t previous_carries) {
+
+  int8x16_t right1 = vreinterpretq_s8_u8(vqsubq_u8(
+      vreinterpretq_u8_s8(vextq_s8(previous_carries, initial_lengths, 16 - 1)),
+      vdupq_n_u8(1)));
+  int8x16_t sum = vaddq_s8(initial_lengths, right1);
+
+  int8x16_t right2 = vreinterpretq_s8_u8(
+      vqsubq_u8(vreinterpretq_u8_s8(vextq_s8(previous_carries, sum, 16 - 2)),
+                vdupq_n_u8(2)));
+  return vaddq_s8(sum, right2);
+}
+
+static inline void check_continuations(int8x16_t initial_lengths,
+                                       int8x16_t carries,
+                                       int8x16_t *has_error) {
+
+  // overlap || underlap
+  // carry > length && length > 0 || !(carry > length) && !(length > 0)
+  // (carries > length) == (lengths > 0)
+  uint8x16_t overunder = vceqq_u8(vcgtq_s8(carries, initial_lengths),
+                                  vcgtq_s8(initial_lengths, vdupq_n_s8(0)));
+
+  *has_error = vorrq_s8(*has_error, vreinterpretq_s8_u8(overunder));
+}
+
+// when 0xED is found, next byte must be no larger than 0x9F
+// when 0xF4 is found, next byte must be no larger than 0x8F
+// next byte must be continuation, ie sign bit is set, so signed < is ok
+static inline void check_first_continuation_max(int8x16_t current_bytes,
+                                                int8x16_t off1_current_bytes,
+                                                int8x16_t *has_error) {
+  uint8x16_t maskED = vceqq_s8(off1_current_bytes, vdupq_n_s8(0xED));
+  uint8x16_t maskF4 = vceqq_s8(off1_current_bytes, vdupq_n_s8(0xF4));
+
+  uint8x16_t badfollowED =
+      vandq_u8(vcgtq_s8(current_bytes, vdupq_n_s8(0x9F)), maskED);
+  uint8x16_t badfollowF4 =
+      vandq_u8(vcgtq_s8(current_bytes, vdupq_n_s8(0x8F)), maskF4);
+
+  *has_error = vorrq_s8(
+      *has_error, vreinterpretq_s8_u8(vorrq_u8(badfollowED, badfollowF4)));
+}
+
+static const int8_t _initial_mins[] = {
+    -128,         -128, -128, -128, -128, -128,
+    -128,         -128, -128, -128, -128, -128, // 10xx => false
+    (int8_t)0xC2, -128,                         // 110x
+    (int8_t)0xE1,                               // 1110
+    (int8_t)0xF1,
+};
+
+static const int8_t _second_mins[] = {
+    -128,         -128, -128, -128, -128, -128,
+    -128,         -128, -128, -128, -128, -128, // 10xx => false
+    127,          127,                          // 110x => true
+    (int8_t)0xA0,                               // 1110
+    (int8_t)0x90,
+};
+
+// map off1_hibits => error condition
+// hibits     off1    cur
+// C       => < C2 && true
+// E       => < E1 && < A0
+// F       => < F1 && < 90
+// else      false && false
+static inline void check_overlong(int8x16_t current_bytes,
+                                  int8x16_t off1_current_bytes,
+                                  int8x16_t hibits, int8x16_t previous_hibits,
+                                  int8x16_t *has_error) {
+  int8x16_t off1_hibits = vextq_s8(previous_hibits, hibits, 16 - 1);
+  int8x16_t initial_mins =
+      vqtbl1q_s8(vld1q_s8(_initial_mins), vreinterpretq_u8_s8(off1_hibits));
+
+  uint8x16_t initial_under = vcgtq_s8(initial_mins, off1_current_bytes);
+
+  int8x16_t second_mins =
+      vqtbl1q_s8(vld1q_s8(_second_mins), vreinterpretq_u8_s8(off1_hibits));
+  uint8x16_t second_under = vcgtq_s8(second_mins, current_bytes);
+  *has_error = vorrq_s8(
+      *has_error, vreinterpretq_s8_u8(vandq_u8(initial_under, second_under)));
+}
+
+struct processed_utf_bytes {
+  int8x16_t raw_bytes;
+  int8x16_t high_nibbles;
+  int8x16_t carried_continuations;
+};
+
+static inline void count_nibbles(int8x16_t bytes,
+                                 struct processed_utf_bytes *answer) {
+  answer->raw_bytes = bytes;
+  answer->high_nibbles =
+      vreinterpretq_s8_u8(vshrq_n_u8(vreinterpretq_u8_s8(bytes), 4));
+}
+
+// check whether the current bytes are valid UTF-8
+// at the end of the function, previous gets updated
+static inline struct processed_utf_bytes
+check_utf8_bytes(int8x16_t current_bytes, struct processed_utf_bytes *previous,
+                 int8x16_t *has_error) {
+  struct processed_utf_bytes pb;
+  count_nibbles(current_bytes, &pb);
+
+  check_smaller_than_0xF4(current_bytes, has_error);
+
+  int8x16_t initial_lengths = continuation_lengths(pb.high_nibbles);
+
+  pb.carried_continuations =
+      carry_continuations(initial_lengths, previous->carried_continuations);
+
+  check_continuations(initial_lengths, pb.carried_continuations, has_error);
+
+  int8x16_t off1_current_bytes =
+      vextq_s8(previous->raw_bytes, pb.raw_bytes, 16 - 1);
+  check_first_continuation_max(current_bytes, off1_current_bytes, has_error);
+
+  check_overlong(current_bytes, off1_current_bytes, pb.high_nibbles,
+                 previous->high_nibbles, has_error);
+  return pb;
+}
+} // namespace simdjson
+#endif
+#endif

data/vendor/simdjson/include/simdjson/simdutf8check_haswell.h

@@ -0,0 +1,198 @@
+#ifndef SIMDJSON_SIMDUTF8CHECK_HASWELL_H
+#define SIMDJSON_SIMDUTF8CHECK_HASWELL_H
+
+#include "simdjson/portability.h"
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#ifdef IS_X86_64
+/*
+ * legal utf-8 byte sequence
+ * http://www.unicode.org/versions/Unicode6.0.0/ch03.pdf - page 94
+ *
+ *  Code Points        1st       2s       3s       4s
+ * U+0000..U+007F     00..7F
+ * U+0080..U+07FF     C2..DF   80..BF
+ * U+0800..U+0FFF     E0       A0..BF   80..BF
+ * U+1000..U+CFFF     E1..EC   80..BF   80..BF
+ * U+D000..U+D7FF     ED       80..9F   80..BF
+ * U+E000..U+FFFF     EE..EF   80..BF   80..BF
+ * U+10000..U+3FFFF   F0       90..BF   80..BF   80..BF
+ * U+40000..U+FFFFF   F1..F3   80..BF   80..BF   80..BF
+ * U+100000..U+10FFFF F4       80..8F   80..BF   80..BF
+ *
+ */
+
+// all byte values must be no larger than 0xF4
+
+TARGET_HASWELL
+namespace simdjson {
+static inline __m256i push_last_byte_of_a_to_b(__m256i a, __m256i b) {
+  return _mm256_alignr_epi8(b, _mm256_permute2x128_si256(a, b, 0x21), 15);
+}
+
+static inline __m256i push_last_2bytes_of_a_to_b(__m256i a, __m256i b) {
+  return _mm256_alignr_epi8(b, _mm256_permute2x128_si256(a, b, 0x21), 14);
+}
+
+// all byte values must be no larger than 0xF4
+static inline void avx_check_smaller_than_0xF4(__m256i current_bytes,
+                                               __m256i *has_error) {
+  // unsigned, saturates to 0 below max
+  *has_error = _mm256_or_si256(
+      *has_error, _mm256_subs_epu8(current_bytes, _mm256_set1_epi8(0xF4u)));
+}
+
+static inline __m256i avx_continuation_lengths(__m256i high_nibbles) {
+  return _mm256_shuffle_epi8(
+      _mm256_setr_epi8(1, 1, 1, 1, 1, 1, 1, 1, // 0xxx (ASCII)
+                       0, 0, 0, 0,             // 10xx (continuation)
+                       2, 2,                   // 110x
+                       3,                      // 1110
+                       4, // 1111, next should be 0 (not checked here)
+                       1, 1, 1, 1, 1, 1, 1, 1, // 0xxx (ASCII)
+                       0, 0, 0, 0,             // 10xx (continuation)
+                       2, 2,                   // 110x
+                       3,                      // 1110
+                       4 // 1111, next should be 0 (not checked here)
+                       ),
+      high_nibbles);
+}
+
+static inline __m256i avx_carry_continuations(__m256i initial_lengths,
+                                              __m256i previous_carries) {
+
+  __m256i right1 = _mm256_subs_epu8(
+      push_last_byte_of_a_to_b(previous_carries, initial_lengths),
+      _mm256_set1_epi8(1));
+  __m256i sum = _mm256_add_epi8(initial_lengths, right1);
+
+  __m256i right2 = _mm256_subs_epu8(
+      push_last_2bytes_of_a_to_b(previous_carries, sum), _mm256_set1_epi8(2));
+  return _mm256_add_epi8(sum, right2);
+}
+
+static inline void avx_check_continuations(__m256i initial_lengths,
+                                           __m256i carries,
+                                           __m256i *has_error) {
+
+  // overlap || underlap
+  // carry > length && length > 0 || !(carry > length) && !(length > 0)
+  // (carries > length) == (lengths > 0)
+  __m256i overunder = _mm256_cmpeq_epi8(
+      _mm256_cmpgt_epi8(carries, initial_lengths),
+      _mm256_cmpgt_epi8(initial_lengths, _mm256_setzero_si256()));
+
+  *has_error = _mm256_or_si256(*has_error, overunder);
+}
+
+// when 0xED is found, next byte must be no larger than 0x9F
+// when 0xF4 is found, next byte must be no larger than 0x8F
+// next byte must be continuation, ie sign bit is set, so signed < is ok
+static inline void avx_check_first_continuation_max(__m256i current_bytes,
+                                                    __m256i off1_current_bytes,
+                                                    __m256i *has_error) {
+  __m256i maskED =
+      _mm256_cmpeq_epi8(off1_current_bytes, _mm256_set1_epi8(0xEDu));
+  __m256i maskF4 =
+      _mm256_cmpeq_epi8(off1_current_bytes, _mm256_set1_epi8(0xF4u));
+
+  __m256i badfollowED = _mm256_and_si256(
+      _mm256_cmpgt_epi8(current_bytes, _mm256_set1_epi8(0x9Fu)), maskED);
+  __m256i badfollowF4 = _mm256_and_si256(
+      _mm256_cmpgt_epi8(current_bytes, _mm256_set1_epi8(0x8Fu)), maskF4);
+
+  *has_error =
+      _mm256_or_si256(*has_error, _mm256_or_si256(badfollowED, badfollowF4));
+}
+
+// map off1_hibits => error condition
+// hibits     off1    cur
+// C       => < C2 && true
+// E       => < E1 && < A0
+// F       => < F1 && < 90
+// else      false && false
+static inline void avx_check_overlong(__m256i current_bytes,
+                                      __m256i off1_current_bytes,
+                                      __m256i hibits, __m256i previous_hibits,
+                                      __m256i *has_error) {
+  __m256i off1_hibits = push_last_byte_of_a_to_b(previous_hibits, hibits);
+  __m256i initial_mins = _mm256_shuffle_epi8(
+      _mm256_setr_epi8(-128, -128, -128, -128, -128, -128, -128, -128, -128,
+                       -128, -128, -128, // 10xx => false
+                       0xC2u, -128,      // 110x
+                       0xE1u,            // 1110
+                       0xF1u,            // 1111
+                       -128, -128, -128, -128, -128, -128, -128, -128, -128,
+                       -128, -128, -128, // 10xx => false
+                       0xC2u, -128,      // 110x
+                       0xE1u,            // 1110
+                       0xF1u),           // 1111
+      off1_hibits);
+
+  __m256i initial_under = _mm256_cmpgt_epi8(initial_mins, off1_current_bytes);
+
+  __m256i second_mins = _mm256_shuffle_epi8(
+      _mm256_setr_epi8(-128, -128, -128, -128, -128, -128, -128, -128, -128,
+                       -128, -128, -128, // 10xx => false
+                       127, 127,         // 110x => true
+                       0xA0u,            // 1110
+                       0x90u,            // 1111
+                       -128, -128, -128, -128, -128, -128, -128, -128, -128,
+                       -128, -128, -128, // 10xx => false
+                       127, 127,         // 110x => true
+                       0xA0u,            // 1110
+                       0x90u),           // 1111
+      off1_hibits);
+  __m256i second_under = _mm256_cmpgt_epi8(second_mins, current_bytes);
+  *has_error = _mm256_or_si256(*has_error,
+                               _mm256_and_si256(initial_under, second_under));
+}
+
+struct avx_processed_utf_bytes {
+  __m256i raw_bytes;
+  __m256i high_nibbles;
+  __m256i carried_continuations;
+};
+
+static inline void avx_count_nibbles(__m256i bytes,
+                                     struct avx_processed_utf_bytes *answer) {
+  answer->raw_bytes = bytes;
+  answer->high_nibbles =
+      _mm256_and_si256(_mm256_srli_epi16(bytes, 4), _mm256_set1_epi8(0x0F));
+}
+
+// check whether the current bytes are valid UTF-8
+// at the end of the function, previous gets updated
+static inline struct avx_processed_utf_bytes
+avx_check_utf8_bytes(__m256i current_bytes,
+                     struct avx_processed_utf_bytes *previous,
+                     __m256i *has_error) {
+  struct avx_processed_utf_bytes pb {};
+  avx_count_nibbles(current_bytes, &pb);
+
+  avx_check_smaller_than_0xF4(current_bytes, has_error);
+
+  __m256i initial_lengths = avx_continuation_lengths(pb.high_nibbles);
+
+  pb.carried_continuations =
+      avx_carry_continuations(initial_lengths, previous->carried_continuations);
+
+  avx_check_continuations(initial_lengths, pb.carried_continuations, has_error);
+
+  __m256i off1_current_bytes =
+      push_last_byte_of_a_to_b(previous->raw_bytes, pb.raw_bytes);
+  avx_check_first_continuation_max(current_bytes, off1_current_bytes,
+                                   has_error);
+
+  avx_check_overlong(current_bytes, off1_current_bytes, pb.high_nibbles,
+                     previous->high_nibbles, has_error);
+  return pb;
+}
+} // namespace simdjson
+UNTARGET_REGION // haswell
+
+#endif // IS_X86_64
+
+#endif

data/vendor/simdjson/include/simdjson/simdutf8check_westmere.h

@@ -0,0 +1,169 @@
+#ifndef SIMDJSON_SIMDUTF8CHECK_WESTMERE_H
+#define SIMDJSON_SIMDUTF8CHECK_WESTMERE_H
+
+#include "simdjson/portability.h"
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#ifdef IS_X86_64
+
+/*
+ * legal utf-8 byte sequence
+ * http://www.unicode.org/versions/Unicode6.0.0/ch03.pdf - page 94
+ *
+ *  Code Points        1st       2s       3s       4s
+ * U+0000..U+007F     00..7F
+ * U+0080..U+07FF     C2..DF   80..BF
+ * U+0800..U+0FFF     E0       A0..BF   80..BF
+ * U+1000..U+CFFF     E1..EC   80..BF   80..BF
+ * U+D000..U+D7FF     ED       80..9F   80..BF
+ * U+E000..U+FFFF     EE..EF   80..BF   80..BF
+ * U+10000..U+3FFFF   F0       90..BF   80..BF   80..BF
+ * U+40000..U+FFFFF   F1..F3   80..BF   80..BF   80..BF
+ * U+100000..U+10FFFF F4       80..8F   80..BF   80..BF
+ *
+ */
+
+// all byte values must be no larger than 0xF4
+
+/********** sse code **********/
+TARGET_WESTMERE
+
+namespace simdjson {
+// all byte values must be no larger than 0xF4
+static inline void check_smaller_than_0xF4(__m128i current_bytes,
+                                           __m128i *has_error) {
+  // unsigned, saturates to 0 below max
+  *has_error = _mm_or_si128(*has_error,
+                            _mm_subs_epu8(current_bytes, _mm_set1_epi8(0xF4u)));
+}
+
+static inline __m128i continuation_lengths(__m128i high_nibbles) {
+  return _mm_shuffle_epi8(
+      _mm_setr_epi8(1, 1, 1, 1, 1, 1, 1, 1, // 0xxx (ASCII)
+                    0, 0, 0, 0,             // 10xx (continuation)
+                    2, 2,                   // 110x
+                    3,                      // 1110
+                    4), // 1111, next should be 0 (not checked here)
+      high_nibbles);
+}
+
+static inline __m128i carry_continuations(__m128i initial_lengths,
+                                          __m128i previous_carries) {
+
+  __m128i right1 =
+      _mm_subs_epu8(_mm_alignr_epi8(initial_lengths, previous_carries, 16 - 1),
+                    _mm_set1_epi8(1));
+  __m128i sum = _mm_add_epi8(initial_lengths, right1);
+
+  __m128i right2 = _mm_subs_epu8(_mm_alignr_epi8(sum, previous_carries, 16 - 2),
+                                 _mm_set1_epi8(2));
+  return _mm_add_epi8(sum, right2);
+}
+
+static inline void check_continuations(__m128i initial_lengths, __m128i carries,
+                                       __m128i *has_error) {
+
+  // overlap || underlap
+  // carry > length && length > 0 || !(carry > length) && !(length > 0)
+  // (carries > length) == (lengths > 0)
+  __m128i overunder =
+      _mm_cmpeq_epi8(_mm_cmpgt_epi8(carries, initial_lengths),
+                     _mm_cmpgt_epi8(initial_lengths, _mm_setzero_si128()));
+
+  *has_error = _mm_or_si128(*has_error, overunder);
+}
+
+// when 0xED is found, next byte must be no larger than 0x9F
+// when 0xF4 is found, next byte must be no larger than 0x8F
+// next byte must be continuation, ie sign bit is set, so signed < is ok
+static inline void check_first_continuation_max(__m128i current_bytes,
+                                                __m128i off1_current_bytes,
+                                                __m128i *has_error) {
+  __m128i maskED = _mm_cmpeq_epi8(off1_current_bytes, _mm_set1_epi8(0xEDu));
+  __m128i maskF4 = _mm_cmpeq_epi8(off1_current_bytes, _mm_set1_epi8(0xF4u));
+
+  __m128i badfollowED = _mm_and_si128(
+      _mm_cmpgt_epi8(current_bytes, _mm_set1_epi8(0x9Fu)), maskED);
+  __m128i badfollowF4 = _mm_and_si128(
+      _mm_cmpgt_epi8(current_bytes, _mm_set1_epi8(0x8Fu)), maskF4);
+
+  *has_error = _mm_or_si128(*has_error, _mm_or_si128(badfollowED, badfollowF4));
+}
+
+// map off1_hibits => error condition
+// hibits     off1    cur
+// C       => < C2 && true
+// E       => < E1 && < A0
+// F       => < F1 && < 90
+// else      false && false
+static inline void check_overlong(__m128i current_bytes,
+                                  __m128i off1_current_bytes, __m128i hibits,
+                                  __m128i previous_hibits, __m128i *has_error) {
+  __m128i off1_hibits = _mm_alignr_epi8(hibits, previous_hibits, 16 - 1);
+  __m128i initial_mins = _mm_shuffle_epi8(
+      _mm_setr_epi8(-128, -128, -128, -128, -128, -128, -128, -128, -128, -128,
+                    -128, -128,  // 10xx => false
+                    0xC2u, -128, // 110x
+                    0xE1u,       // 1110
+                    0xF1u),
+      off1_hibits);
+
+  __m128i initial_under = _mm_cmpgt_epi8(initial_mins, off1_current_bytes);
+
+  __m128i second_mins = _mm_shuffle_epi8(
+      _mm_setr_epi8(-128, -128, -128, -128, -128, -128, -128, -128, -128, -128,
+                    -128, -128, // 10xx => false
+                    127, 127,   // 110x => true
+                    0xA0u,      // 1110
+                    0x90u),
+      off1_hibits);
+  __m128i second_under = _mm_cmpgt_epi8(second_mins, current_bytes);
+  *has_error =
+      _mm_or_si128(*has_error, _mm_and_si128(initial_under, second_under));
+}
+
+struct processed_utf_bytes {
+  __m128i raw_bytes;
+  __m128i high_nibbles;
+  __m128i carried_continuations;
+};
+
+static inline void count_nibbles(__m128i bytes,
+                                 struct processed_utf_bytes *answer) {
+  answer->raw_bytes = bytes;
+  answer->high_nibbles =
+      _mm_and_si128(_mm_srli_epi16(bytes, 4), _mm_set1_epi8(0x0F));
+}
+
+// check whether the current bytes are valid UTF-8
+// at the end of the function, previous gets updated
+static struct processed_utf_bytes
+check_utf8_bytes(__m128i current_bytes, struct processed_utf_bytes *previous,
+                 __m128i *has_error) {
+  struct processed_utf_bytes pb;
+  count_nibbles(current_bytes, &pb);
+
+  check_smaller_than_0xF4(current_bytes, has_error);
+
+  __m128i initial_lengths = continuation_lengths(pb.high_nibbles);
+
+  pb.carried_continuations =
+      carry_continuations(initial_lengths, previous->carried_continuations);
+
+  check_continuations(initial_lengths, pb.carried_continuations, has_error);
+
+  __m128i off1_current_bytes =
+      _mm_alignr_epi8(pb.raw_bytes, previous->raw_bytes, 16 - 1);
+  check_first_continuation_max(current_bytes, off1_current_bytes, has_error);
+
+  check_overlong(current_bytes, off1_current_bytes, pb.high_nibbles,
+                 previous->high_nibbles, has_error);
+  return pb;
+}
+} // namespace simdjson
+UNTARGET_REGION // westmere
+
+#endif // IS_X86_64
+
+#endif

data/vendor/simdjson/include/simdjson/stage1_find_marks.h

@@ -0,0 +1,121 @@
+#ifndef SIMDJSON_STAGE1_FIND_MARKS_H
+#define SIMDJSON_STAGE1_FIND_MARKS_H
+
+#include "simdjson/common_defs.h"
+#include "simdjson/parsedjson.h"
+#include "simdjson/portability.h"
+#include "simdjson/simdjson.h"
+#include <cassert>
+
+namespace simdjson {
+
+template <Architecture> struct simd_input;
+
+template <Architecture> uint64_t compute_quote_mask(uint64_t quote_bits);
+
+namespace {
+// for when clmul is unavailable
+[[maybe_unused]] uint64_t portable_compute_quote_mask(uint64_t quote_bits) {
+  uint64_t quote_mask = quote_bits ^ (quote_bits << 1);
+  quote_mask = quote_mask ^ (quote_mask << 2);
+  quote_mask = quote_mask ^ (quote_mask << 4);
+  quote_mask = quote_mask ^ (quote_mask << 8);
+  quote_mask = quote_mask ^ (quote_mask << 16);
+  quote_mask = quote_mask ^ (quote_mask << 32);
+  return quote_mask;
+}
+} // namespace
+
+// Holds the state required to perform check_utf8().
+template <Architecture> struct utf8_checking_state;
+
+template <Architecture T>
+void check_utf8(simd_input<T> in, utf8_checking_state<T> &state);
+
+// Checks if the utf8 validation has found any error.
+template <Architecture T>
+ErrorValues check_utf8_errors(utf8_checking_state<T> &state);
+
+// a straightforward comparison of a mask against input.
+template <Architecture T>
+uint64_t cmp_mask_against_input(simd_input<T> in, uint8_t m);
+
+template <Architecture T> simd_input<T> fill_input(const uint8_t *ptr);
+
+// find all values less than or equal than the content of maxval (using unsigned
+// arithmetic)
+template <Architecture T>
+uint64_t unsigned_lteq_against_input(simd_input<T> in, uint8_t m);
+
+template <Architecture T>
+really_inline uint64_t find_odd_backslash_sequences(
+    simd_input<T> in, uint64_t &prev_iter_ends_odd_backslash);
+
+template <Architecture T>
+really_inline uint64_t find_quote_mask_and_bits(
+    simd_input<T> in, uint64_t odd_ends, uint64_t &prev_iter_inside_quote,
+    uint64_t &quote_bits, uint64_t &error_mask);
+
+// do a 'shufti' to detect structural JSON characters
+// they are { 0x7b } 0x7d : 0x3a [ 0x5b ] 0x5d , 0x2c
+// these go into the first 3 buckets of the comparison (1/2/4)
+
+// we are also interested in the four whitespace characters
+// space 0x20, linefeed 0x0a, horizontal tab 0x09 and carriage return 0x0d
+// these go into the next 2 buckets of the comparison (8/16)
+template <Architecture T>
+void find_whitespace_and_structurals(simd_input<T> in, uint64_t &whitespace,
+                                     uint64_t &structurals);
+
+// return a updated structural bit vector with quoted contents cleared out and
+// pseudo-structural characters added to the mask
+// updates prev_iter_ends_pseudo_pred which tells us whether the previous
+// iteration ended on a whitespace or a structural character (which means that
+// the next iteration
+// will have a pseudo-structural character at its start)
+really_inline uint64_t finalize_structurals(
+    uint64_t structurals, uint64_t whitespace, uint64_t quote_mask,
+    uint64_t quote_bits, uint64_t &prev_iter_ends_pseudo_pred) {
+  // mask off anything inside quotes
+  structurals &= ~quote_mask;
+  // add the real quote bits back into our bit_mask as well, so we can
+  // quickly traverse the strings we've spent all this trouble gathering
+  structurals |= quote_bits;
+  // Now, establish "pseudo-structural characters". These are non-whitespace
+  // characters that are (a) outside quotes and (b) have a predecessor that's
+  // either whitespace or a structural character. This means that subsequent
+  // passes will get a chance to encounter the first character of every string
+  // of non-whitespace and, if we're parsing an atom like true/false/null or a
+  // number we can stop at the first whitespace or structural character
+  // following it.
+
+  // a qualified predecessor is something that can happen 1 position before an
+  // pseudo-structural character
+  uint64_t pseudo_pred = structurals | whitespace;
+
+  uint64_t shifted_pseudo_pred =
+      (pseudo_pred << 1) | prev_iter_ends_pseudo_pred;
+  prev_iter_ends_pseudo_pred = pseudo_pred >> 63;
+  uint64_t pseudo_structurals =
+      shifted_pseudo_pred & (~whitespace) & (~quote_mask);
+  structurals |= pseudo_structurals;
+
+  // now, we've used our close quotes all we need to. So let's switch them off
+  // they will be off in the quote mask and on in quote bits.
+  structurals &= ~(quote_bits & ~quote_mask);
+  return structurals;
+}
+
+template <Architecture T = Architecture::NATIVE>
+int find_structural_bits(const uint8_t *buf, size_t len,
+                         simdjson::ParsedJson &pj);
+
+template <Architecture T = Architecture::NATIVE>
+int find_structural_bits(const char *buf, size_t len,
+                         simdjson::ParsedJson &pj) {
+  return find_structural_bits((const uint8_t *)buf, len, pj);
+}
+
+} // namespace simdjson
+
+#endif