/* auto-generated on Fri Aug 23 11:02:39 DST 2019. Do not edit! */

#include "simdjson.h"

/* used for http://dmalloc.com/ Dmalloc - Debug Malloc Library */

#ifdef DMALLOC

#include "dmalloc.h"

#endif

/* begin file src/simdjson.cpp */

#include <map>

namespace simdjson {

const std::map<int, const std::string> error_strings = {

{SUCCESS, "No errors"},

{CAPACITY, "This ParsedJson can't support a document that big"},

{MEMALLOC, "Error allocating memory, we're most likely out of memory"},

{TAPE_ERROR, "Something went wrong while writing to the tape"},

{STRING_ERROR, "Problem while parsing a string"},

{T_ATOM_ERROR,

"Problem while parsing an atom starting with the letter 't'"},

{F_ATOM_ERROR,

"Problem while parsing an atom starting with the letter 'f'"},

{N_ATOM_ERROR,

"Problem while parsing an atom starting with the letter 'n'"},

{NUMBER_ERROR, "Problem while parsing a number"},

{UTF8_ERROR, "The input is not valid UTF-8"},

{UNITIALIZED, "Unitialized"},

{EMPTY, "Empty"},

{UNESCAPED_CHARS, "Within strings, some characters must be escapted, we "

"found unescapted characters"},

{UNEXPECTED_ERROR, "Unexpected error, consider reporting this problem as "

"you may have found a bug in simdjson"},

};

const std::string &error_message(const int error_code) {

return error_strings.at(error_code);

}

} // namespace simdjson

/* end file src/simdjson.cpp */

/* begin file src/jsonioutil.cpp */

#include <cstdlib>

#include <cstring>

namespace simdjson {

char *allocate_padded_buffer(size_t length) {

// we could do a simple malloc

// return (char *) malloc(length + SIMDJSON_PADDING);

// However, we might as well align to cache lines...

size_t totalpaddedlength = length + SIMDJSON_PADDING;

char *padded_buffer = aligned_malloc_char(64, totalpaddedlength);

return padded_buffer;

}

padded_string get_corpus(const std::string &filename) {

std::FILE *fp = std::fopen(filename.c_str(), "rb");

if (fp != nullptr) {

std::fseek(fp, 0, SEEK_END);

size_t len = std::ftell(fp);

padded_string s(len);

if (s.data() == nullptr) {

std::fclose(fp);

throw std::runtime_error("could not allocate memory");

}

std::rewind(fp);

size_t readb = std::fread(s.data(), 1, len, fp);

std::fclose(fp);

if (readb != len) {

throw std::runtime_error("could not read the data");

}

return s;

}

throw std::runtime_error("could not load corpus");

}

} // namespace simdjson

/* end file src/jsonioutil.cpp */

/* begin file src/jsonminifier.cpp */

#include <cstdint>

#ifndef __AVX2__

namespace simdjson {

static uint8_t jump_table[256 * 3] = {

0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,

1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1,

1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,

0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0,

1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,

1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,

0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,

1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,

1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,

0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,

1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,

1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,

0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,

1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,

1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,

0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,

1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,

1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,

0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,

1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,

1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,

0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,

1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,

1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,

0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,

1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,

1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,

0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0,

1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1,

1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,

0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1,

};

size_t json_minify(const unsigned char *bytes, size_t how_many,

unsigned char *out) {

size_t i = 0, pos = 0;

uint8_t quote = 0;

uint8_t nonescape = 1;

while (i < how_many) {

unsigned char c = bytes[i];

uint8_t *meta = jump_table + 3 * c;

quote = quote ^ (meta[0] & nonescape);

out[pos] = c;

pos += meta[2] | quote;

i += 1;

nonescape = (~nonescape) | (meta[1]);

}

return pos;

}

} // namespace simdjson

#else

#include <cstring>

namespace simdjson {

// some intrinsics are missing under GCC?

#ifndef __clang__

#ifndef _MSC_VER

static __m256i inline _mm256_loadu2_m128i(__m128i const *__addr_hi,

__m128i const *__addr_lo) {

__m256i __v256 = _mm256_castsi128_si256(_mm_loadu_si128(__addr_lo));

return _mm256_insertf128_si256(__v256, _mm_loadu_si128(__addr_hi), 1);

}

static inline void _mm256_storeu2_m128i(__m128i *__addr_hi, __m128i *__addr_lo,

__m256i __a) {

__m128i __v128;

__v128 = _mm256_castsi256_si128(__a);

_mm_storeu_si128(__addr_lo, __v128);

__v128 = _mm256_extractf128_si256(__a, 1);

_mm_storeu_si128(__addr_hi, __v128);

}

#endif

#endif

// a straightforward comparison of a mask against input.

static uint64_t cmp_mask_against_input_mini(__m256i input_lo, __m256i input_hi,

__m256i mask) {

__m256i cmp_res_0 = _mm256_cmpeq_epi8(input_lo, mask);

uint64_t res_0 = static_cast<uint32_t>(_mm256_movemask_epi8(cmp_res_0));

__m256i cmp_res_1 = _mm256_cmpeq_epi8(input_hi, mask);

uint64_t res_1 = _mm256_movemask_epi8(cmp_res_1);

return res_0 | (res_1 << 32);

}

// take input from buf and remove useless whitespace, input and output can be

// the same, result is null terminated, return the string length (minus the null

// termination)

size_t json_minify(const uint8_t *buf, size_t len, uint8_t *out) {

// Useful constant masks

const uint64_t even_bits = 0x5555555555555555ULL;

const uint64_t odd_bits = ~even_bits;

uint8_t *initout(out);

uint64_t prev_iter_ends_odd_backslash =

0ULL; // either 0 or 1, but a 64-bit value

uint64_t prev_iter_inside_quote = 0ULL; // either all zeros or all ones

size_t idx = 0;

if (len >= 64) {

size_t avx_len = len - 63;

for (; idx < avx_len; idx += 64) {

__m256i input_lo =

_mm256_loadu_si256(reinterpret_cast<const __m256i *>(buf + idx + 0));

__m256i input_hi =

_mm256_loadu_si256(reinterpret_cast<const __m256i *>(buf + idx + 32));

uint64_t bs_bits = cmp_mask_against_input_mini(input_lo, input_hi,

_mm256_set1_epi8('\\'));

uint64_t start_edges = bs_bits & ~(bs_bits << 1);

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;

bool iter_ends_odd_backslash =

add_overflow(bs_bits, odd_starts, &odd_carries);

odd_carries |= prev_iter_ends_odd_backslash;

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;

uint64_t quote_bits = cmp_mask_against_input_mini(input_lo, input_hi,

_mm256_set1_epi8('"'));

quote_bits = quote_bits & ~odd_ends;

uint64_t quote_mask = _mm_cvtsi128_si64(_mm_clmulepi64_si128(

_mm_set_epi64x(0ULL, quote_bits), _mm_set1_epi8(0xFF), 0));

quote_mask ^= prev_iter_inside_quote;

prev_iter_inside_quote = static_cast<uint64_t>(

static_cast<int64_t>(quote_mask) >>

63); // might be undefined behavior, should be fully defined in C++20,

// ok according to John Regher from Utah University

const __m256i low_nibble_mask = _mm256_setr_epi8(

// 0 9 a b c d

16, 0, 0, 0, 0, 0, 0, 0, 0, 8, 12, 1, 2, 9, 0, 0, 16, 0, 0, 0, 0, 0,

0, 0, 0, 8, 12, 1, 2, 9, 0, 0);

const __m256i high_nibble_mask = _mm256_setr_epi8(

// 0 2 3 5 7

8, 0, 18, 4, 0, 1, 0, 1, 0, 0, 0, 3, 2, 1, 0, 0, 8, 0, 18, 4, 0, 1, 0,

1, 0, 0, 0, 3, 2, 1, 0, 0);

__m256i whitespace_shufti_mask = _mm256_set1_epi8(0x18);

__m256i v_lo = _mm256_and_si256(

_mm256_shuffle_epi8(low_nibble_mask, input_lo),

_mm256_shuffle_epi8(high_nibble_mask,

_mm256_and_si256(_mm256_srli_epi32(input_lo, 4),

_mm256_set1_epi8(0x7f))));

__m256i v_hi = _mm256_and_si256(

_mm256_shuffle_epi8(low_nibble_mask, input_hi),

_mm256_shuffle_epi8(high_nibble_mask,

_mm256_and_si256(_mm256_srli_epi32(input_hi, 4),

_mm256_set1_epi8(0x7f))));

__m256i tmp_ws_lo = _mm256_cmpeq_epi8(

_mm256_and_si256(v_lo, whitespace_shufti_mask), _mm256_set1_epi8(0));

__m256i tmp_ws_hi = _mm256_cmpeq_epi8(

_mm256_and_si256(v_hi, whitespace_shufti_mask), _mm256_set1_epi8(0));

uint64_t ws_res_0 =

static_cast<uint32_t>(_mm256_movemask_epi8(tmp_ws_lo));

uint64_t ws_res_1 = _mm256_movemask_epi8(tmp_ws_hi);

uint64_t whitespace = ~(ws_res_0 | (ws_res_1 << 32));

whitespace &= ~quote_mask;

int mask1 = whitespace & 0xFFFF;

int mask2 = (whitespace >> 16) & 0xFFFF;

int mask3 = (whitespace >> 32) & 0xFFFF;

int mask4 = (whitespace >> 48) & 0xFFFF;

int pop1 = hamming((~whitespace) & 0xFFFF);

int pop2 = hamming((~whitespace) & UINT64_C(0xFFFFFFFF));

int pop3 = hamming((~whitespace) & UINT64_C(0xFFFFFFFFFFFF));

int pop4 = hamming((~whitespace));

__m256i vmask1 = _mm256_loadu2_m128i(

reinterpret_cast<const __m128i *>(mask128_epi8) + (mask2 & 0x7FFF),

reinterpret_cast<const __m128i *>(mask128_epi8) + (mask1 & 0x7FFF));

__m256i vmask2 = _mm256_loadu2_m128i(

reinterpret_cast<const __m128i *>(mask128_epi8) + (mask4 & 0x7FFF),

reinterpret_cast<const __m128i *>(mask128_epi8) + (mask3 & 0x7FFF));

__m256i result1 = _mm256_shuffle_epi8(input_lo, vmask1);

__m256i result2 = _mm256_shuffle_epi8(input_hi, vmask2);

_mm256_storeu2_m128i(reinterpret_cast<__m128i *>(out + pop1),

reinterpret_cast<__m128i *>(out), result1);

_mm256_storeu2_m128i(reinterpret_cast<__m128i *>(out + pop3),

reinterpret_cast<__m128i *>(out + pop2), result2);

out += pop4;

}

}

// we finish off the job... copying and pasting the code is not ideal here,

// but it gets the job done.

if (idx < len) {

uint8_t buffer[64];

memset(buffer, 0, 64);

memcpy(buffer, buf + idx, len - idx);

__m256i input_lo =

_mm256_loadu_si256(reinterpret_cast<const __m256i *>(buffer));

__m256i input_hi =

_mm256_loadu_si256(reinterpret_cast<const __m256i *>(buffer + 32));

uint64_t bs_bits =

cmp_mask_against_input_mini(input_lo, input_hi, _mm256_set1_epi8('\\'));

uint64_t start_edges = bs_bits & ~(bs_bits << 1);

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;

// bool iter_ends_odd_backslash =

add_overflow(bs_bits, odd_starts, &odd_carries);

odd_carries |= prev_iter_ends_odd_backslash;

// prev_iter_ends_odd_backslash = iter_ends_odd_backslash ? 0x1ULL : 0x0ULL;

// // we never use it

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;

uint64_t quote_bits =

cmp_mask_against_input_mini(input_lo, input_hi, _mm256_set1_epi8('"'));

quote_bits = quote_bits & ~odd_ends;

uint64_t quote_mask = _mm_cvtsi128_si64(_mm_clmulepi64_si128(

_mm_set_epi64x(0ULL, quote_bits), _mm_set1_epi8(0xFF), 0));

quote_mask ^= prev_iter_inside_quote;

// prev_iter_inside_quote = (uint64_t)((int64_t)quote_mask >> 63);// we

// don't need this anymore

__m256i mask_20 = _mm256_set1_epi8(0x20); // c==32

__m256i mask_70 =

_mm256_set1_epi8(0x70); // adding 0x70 does not check low 4-bits

// but moves any value >= 16 above 128

__m256i lut_cntrl = _mm256_setr_epi8(

0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00,

0x00, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

0x00, 0xFF, 0xFF, 0x00, 0x00, 0xFF, 0x00, 0x00);

__m256i tmp_ws_lo = _mm256_or_si256(

_mm256_cmpeq_epi8(mask_20, input_lo),

_mm256_shuffle_epi8(lut_cntrl, _mm256_adds_epu8(mask_70, input_lo)));

__m256i tmp_ws_hi = _mm256_or_si256(

_mm256_cmpeq_epi8(mask_20, input_hi),

_mm256_shuffle_epi8(lut_cntrl, _mm256_adds_epu8(mask_70, input_hi)));

uint64_t ws_res_0 = static_cast<uint32_t>(_mm256_movemask_epi8(tmp_ws_lo));

uint64_t ws_res_1 = _mm256_movemask_epi8(tmp_ws_hi);

uint64_t whitespace = (ws_res_0 | (ws_res_1 << 32));

whitespace &= ~quote_mask;

if (len - idx < 64) {

whitespace |= UINT64_C(0xFFFFFFFFFFFFFFFF) << (len - idx);

}

int mask1 = whitespace & 0xFFFF;

int mask2 = (whitespace >> 16) & 0xFFFF;

int mask3 = (whitespace >> 32) & 0xFFFF;

int mask4 = (whitespace >> 48) & 0xFFFF;

int pop1 = hamming((~whitespace) & 0xFFFF);

int pop2 = hamming((~whitespace) & UINT64_C(0xFFFFFFFF));

int pop3 = hamming((~whitespace) & UINT64_C(0xFFFFFFFFFFFF));

int pop4 = hamming((~whitespace));

__m256i vmask1 = _mm256_loadu2_m128i(

reinterpret_cast<const __m128i *>(mask128_epi8) + (mask2 & 0x7FFF),

reinterpret_cast<const __m128i *>(mask128_epi8) + (mask1 & 0x7FFF));

__m256i vmask2 = _mm256_loadu2_m128i(

reinterpret_cast<const __m128i *>(mask128_epi8) + (mask4 & 0x7FFF),

reinterpret_cast<const __m128i *>(mask128_epi8) + (mask3 & 0x7FFF));

__m256i result1 = _mm256_shuffle_epi8(input_lo, vmask1);

__m256i result2 = _mm256_shuffle_epi8(input_hi, vmask2);

_mm256_storeu2_m128i(reinterpret_cast<__m128i *>(buffer + pop1),

reinterpret_cast<__m128i *>(buffer), result1);

_mm256_storeu2_m128i(reinterpret_cast<__m128i *>(buffer + pop3),

reinterpret_cast<__m128i *>(buffer + pop2), result2);

memcpy(out, buffer, pop4);

out += pop4;

}

*out = '\0'; // NULL termination

return out - initout;

}

} // namespace simdjson

#endif

/* end file src/jsonminifier.cpp */

/* begin file src/jsonparser.cpp */

#include <atomic>

namespace simdjson {

// The function that users are expected to call is json_parse.

// We have more than one such function because we want to support several

// instruction sets.

// function pointer type for json_parse

using json_parse_functype = int(const uint8_t *buf, size_t len, ParsedJson &pj,

bool realloc);

// Pointer that holds the json_parse implementation corresponding to the

// available SIMD instruction set

extern std::atomic<json_parse_functype *> json_parse_ptr;

int json_parse(const uint8_t *buf, size_t len, ParsedJson &pj,

bool realloc) {

return json_parse_ptr.load(std::memory_order_relaxed)(buf, len, pj, realloc);

}

int json_parse(const char *buf, size_t len, ParsedJson &pj,

bool realloc) {

return json_parse_ptr.load(std::memory_order_relaxed)(reinterpret_cast<const uint8_t *>(buf), len, pj,

realloc);

}

Architecture find_best_supported_implementation() {

constexpr uint32_t haswell_flags =

instruction_set::AVX2 | instruction_set::PCLMULQDQ |

instruction_set::BMI1 | instruction_set::BMI2;

constexpr uint32_t westmere_flags =

instruction_set::SSE42 | instruction_set::PCLMULQDQ;

uint32_t supports = detect_supported_architectures();

// Order from best to worst (within architecture)

if ((haswell_flags & supports) == haswell_flags)

return Architecture::HASWELL;

if ((westmere_flags & supports) == westmere_flags)

return Architecture::WESTMERE;

if (instruction_set::NEON)

return Architecture::ARM64;

return Architecture::NONE;

}

// Responsible to select the best json_parse implementation

int json_parse_dispatch(const uint8_t *buf, size_t len, ParsedJson &pj,

bool realloc) {

Architecture best_implementation = find_best_supported_implementation();

// Selecting the best implementation

switch (best_implementation) {

#ifdef IS_X86_64

case Architecture::HASWELL:

json_parse_ptr.store(&json_parse_implementation<Architecture::HASWELL>, std::memory_order_relaxed);

break;

case Architecture::WESTMERE:

json_parse_ptr.store(&json_parse_implementation<Architecture::WESTMERE>, std::memory_order_relaxed);

break;

#endif

#ifdef IS_ARM64

case Architecture::ARM64:

json_parse_ptr.store(&json_parse_implementation<Architecture::ARM64>, std::memory_order_relaxed);

break;

#endif

default:

std::cerr << "The processor is not supported by simdjson." << std::endl;

return simdjson::UNEXPECTED_ERROR;

}

return json_parse_ptr.load(std::memory_order_relaxed)(buf, len, pj, realloc);

}

std::atomic<json_parse_functype *> json_parse_ptr = &json_parse_dispatch;

WARN_UNUSED

ParsedJson build_parsed_json(const uint8_t *buf, size_t len,

bool realloc) {

ParsedJson pj;

bool ok = pj.allocate_capacity(len);

if (ok) {

json_parse(buf, len, pj, realloc);

} else {

std::cerr << "failure during memory allocation " << std::endl;

}

return pj;

}

} // namespace simdjson

/* end file src/jsonparser.cpp */

/* begin file src/simd_input.h */

#ifndef SIMDJSON_SIMD_INPUT_H

#define SIMDJSON_SIMD_INPUT_H

#include <cassert>

namespace simdjson {

template <Architecture>

struct simd_input {

simd_input(const uint8_t *ptr);

// a straightforward comparison of a mask against input.

uint64_t eq(uint8_t m);

// find all values less than or equal than the content of maxval (using unsigned arithmetic)

uint64_t lteq(uint8_t m);

}; // struct simd_input

} // namespace simdjson

#endif

/* end file src/simd_input.h */

/* begin file src/arm64/architecture.h */

#ifndef SIMDJSON_ARM64_ARCHITECTURE_H

#define SIMDJSON_ARM64_ARCHITECTURE_H

#ifdef IS_ARM64

namespace simdjson::arm64 {

static const Architecture ARCHITECTURE = Architecture::ARM64;

} // namespace simdjson::arm64

#endif // IS_ARM64

#endif // SIMDJSON_ARM64_ARCHITECTURE_H

/* end file src/arm64/architecture.h */

/* begin file src/haswell/architecture.h */

#ifndef SIMDJSON_HASWELL_ARCHITECTURE_H

#define SIMDJSON_HASWELL_ARCHITECTURE_H

#ifdef IS_X86_64

namespace simdjson::haswell {

static const Architecture ARCHITECTURE = Architecture::HASWELL;

} // namespace simdjson::haswell

#endif // IS_X86_64

#endif // SIMDJSON_HASWELL_ARCHITECTURE_H

/* end file src/haswell/architecture.h */

/* begin file src/westmere/architecture.h */

#ifndef SIMDJSON_WESTMERE_ARCHITECTURE_H

#define SIMDJSON_WESTMERE_ARCHITECTURE_H

#ifdef IS_X86_64

namespace simdjson::westmere {

static const Architecture ARCHITECTURE = Architecture::WESTMERE;

} // namespace simdjson::westmere

#endif // IS_X86_64

#endif // SIMDJSON_WESTMERE_ARCHITECTURE_H

/* end file src/westmere/architecture.h */

/* begin file src/arm64/simd_input.h */

#ifndef SIMDJSON_ARM64_SIMD_INPUT_H

#define SIMDJSON_ARM64_SIMD_INPUT_H

#ifdef IS_ARM64

namespace simdjson {

really_inline uint16_t neon_movemask(uint8x16_t input) {

const uint8x16_t bit_mask = {0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,

0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80};

uint8x16_t minput = vandq_u8(input, bit_mask);

uint8x16_t tmp = vpaddq_u8(minput, minput);

tmp = vpaddq_u8(tmp, tmp);

tmp = vpaddq_u8(tmp, tmp);

return vgetq_lane_u16(vreinterpretq_u16_u8(tmp), 0);

}

really_inline uint64_t neon_movemask_bulk(uint8x16_t p0, uint8x16_t p1,

uint8x16_t p2, uint8x16_t p3) {

const uint8x16_t bit_mask = {0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80,

0x01, 0x02, 0x4, 0x8, 0x10, 0x20, 0x40, 0x80};

uint8x16_t t0 = vandq_u8(p0, bit_mask);

uint8x16_t t1 = vandq_u8(p1, bit_mask);

uint8x16_t t2 = vandq_u8(p2, bit_mask);

uint8x16_t t3 = vandq_u8(p3, bit_mask);

uint8x16_t sum0 = vpaddq_u8(t0, t1);

uint8x16_t sum1 = vpaddq_u8(t2, t3);

sum0 = vpaddq_u8(sum0, sum1);

sum0 = vpaddq_u8(sum0, sum0);

return vgetq_lane_u64(vreinterpretq_u64_u8(sum0), 0);

}

template <>

struct simd_input<Architecture::ARM64> {

uint8x16_t i0;

uint8x16_t i1;

uint8x16_t i2;

uint8x16_t i3;

really_inline simd_input(const uint8_t *ptr) {

this->i0 = vld1q_u8(ptr + 0);

this->i1 = vld1q_u8(ptr + 16);

this->i2 = vld1q_u8(ptr + 32);

this->i3 = vld1q_u8(ptr + 48);

}

template <typename F>

really_inline uint64_t build_bitmask(F const& chunk_to_mask) {

uint8x16_t r0 = chunk_to_mask(this->i0);

uint8x16_t r1 = chunk_to_mask(this->i1);

uint8x16_t r2 = chunk_to_mask(this->i2);

uint8x16_t r3 = chunk_to_mask(this->i3);

return neon_movemask_bulk(r0, r1, r2, r3);

}

template <typename F>

really_inline simd_input<Architecture::ARM64> map(F const& map_chunk) {

simd_input<Architecture::ARM64> result = {

map_chunk(this->i0),

map_chunk(this->i1),

map_chunk(this->i2),

map_chunk(this->i3)

};

return result;

}

really_inline uint64_t eq(uint8_t m) {

const uint8x16_t mask = vmovq_n_u8(m);

return this->build_bitmask([&](uint8x16_t chunk) {

return vceqq_u8(chunk, mask);

});

}

really_inline uint64_t lteq(uint8_t m) {

const uint8x16_t mask = vmovq_n_u8(m);

return this->build_bitmask([&](uint8x16_t chunk) {

return vcleq_u8(chunk, mask);

});

}

}; // struct simd_input

} // namespace simdjson

#endif // IS_ARM64

#endif // SIMDJSON_ARM64_SIMD_INPUT_H

/* end file src/arm64/simd_input.h */

/* begin file src/haswell/simd_input.h */

#ifndef SIMDJSON_HASWELL_SIMD_INPUT_H

#define SIMDJSON_HASWELL_SIMD_INPUT_H

#ifdef IS_X86_64

TARGET_HASWELL

namespace simdjson {

template <>

struct simd_input<Architecture::HASWELL> {

__m256i lo;

__m256i hi;

really_inline simd_input(const uint8_t *ptr) {

this->lo = _mm256_loadu_si256(reinterpret_cast<const __m256i *>(ptr + 0));

this->hi = _mm256_loadu_si256(reinterpret_cast<const __m256i *>(ptr + 32));

}

template <typename F>

really_inline uint64_t build_bitmask(F const& chunk_to_mask) {

uint64_t r0 = static_cast<uint32_t>(_mm256_movemask_epi8(chunk_to_mask(this->lo)));

uint64_t r1 = _mm256_movemask_epi8(chunk_to_mask(this->hi));

return r0 | (r1 << 32);

}

really_inline uint64_t eq(uint8_t m) {

const __m256i mask = _mm256_set1_epi8(m);

return this->build_bitmask([&] (auto chunk) {

return _mm256_cmpeq_epi8(chunk, mask);

});

}

really_inline uint64_t lteq(uint8_t m) {

const __m256i maxval = _mm256_set1_epi8(m);

return this->build_bitmask([&] (auto chunk) {

return _mm256_cmpeq_epi8(_mm256_max_epu8(maxval, chunk), maxval);

});

}

}; // struct simd_input

} // namespace simdjson

UNTARGET_REGION

#endif // IS_X86_64

#endif // SIMDJSON_HASWELL_SIMD_INPUT_H

/* end file src/haswell/simd_input.h */

/* begin file src/westmere/simd_input.h */

#ifndef SIMDJSON_WESTMERE_SIMD_INPUT_H

#define SIMDJSON_WESTMERE_SIMD_INPUT_H

#ifdef IS_X86_64

TARGET_WESTMERE

namespace simdjson {

template <>

struct simd_input<Architecture::WESTMERE> {

__m128i v0;

__m128i v1;

__m128i v2;

__m128i v3;

really_inline simd_input(const uint8_t *ptr) {

this->v0 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(ptr + 0));

this->v1 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(ptr + 16));

this->v2 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(ptr + 32));

this->v3 = _mm_loadu_si128(reinterpret_cast<const __m128i *>(ptr + 48));

}

template <typename F>

really_inline uint64_t build_bitmask(F const& chunk_to_mask) {

uint64_t r0 = static_cast<uint32_t>(_mm_movemask_epi8(chunk_to_mask(this->v0)));

uint64_t r1 = _mm_movemask_epi8(chunk_to_mask(this->v1));

uint64_t r2 = _mm_movemask_epi8(chunk_to_mask(this->v2));

uint64_t r3 = _mm_movemask_epi8(chunk_to_mask(this->v3));

return r0 | (r1 << 16) | (r2 << 32) | (r3 << 48);

}

really_inline uint64_t eq(uint8_t m) {

const __m128i mask = _mm_set1_epi8(m);

return this->build_bitmask([&](auto chunk) {

return _mm_cmpeq_epi8(chunk, mask);

});

}

really_inline uint64_t lteq(uint8_t m) {

const __m128i maxval = _mm_set1_epi8(m);

return this->build_bitmask([&](auto chunk) {

return _mm_cmpeq_epi8(_mm_max_epu8(maxval, chunk), maxval);

});

}

}; // struct simd_input

} // namespace simdjson

UNTARGET_REGION

#endif // IS_X86_64

#endif // SIMDJSON_WESTMERE_SIMD_INPUT_H

/* end file src/westmere/simd_input.h */

/* begin file src/simdutf8check.h */

#ifndef SIMDJSON_SIMDUTF8CHECK_H

#define SIMDJSON_SIMDUTF8CHECK_H

namespace simdjson {

// Checks UTF8, chunk by chunk.

template <Architecture T>

struct utf8_checker {

// Process the next chunk of input.

void check_next_input(simd_input<T> in);

// Find out what (if any) errors have occurred

ErrorValues errors();

};

} // namespace simdjson

#endif // SIMDJSON_SIMDUTF8CHECK_H

/* end file src/simdutf8check.h */

/* begin file src/arm64/simdutf8check.h */

// From https://github.com/cyb70289/utf8/blob/master/lemire-neon.c

// Adapted from https://github.com/lemire/fastvalidate-utf-8

#ifndef SIMDJSON_ARM64_SIMDUTF8CHECK_H

#define SIMDJSON_ARM64_SIMDUTF8CHECK_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::arm64 {

// 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;

}

// Checks that all bytes are ascii

really_inline bool check_ascii_neon(simd_input<Architecture::ARM64> in) {

// checking if the most significant bit is always equal to 0.

uint8x16_t high_bit = vdupq_n_u8(0x80);

uint8x16_t t0 = vorrq_u8(in.i0, in.i1);

uint8x16_t t1 = vorrq_u8(in.i2, in.i3);

uint8x16_t t3 = vorrq_u8(t0, t1);

uint8x16_t t4 = vandq_u8(t3, high_bit);

uint64x2_t v64 = vreinterpretq_u64_u8(t4);

uint32x2_t v32 = vqmovn_u64(v64);

uint64x1_t result = vreinterpret_u64_u32(v32);

return vget_lane_u64(result, 0) == 0;

}

} // namespace simdjson::arm64

namespace simdjson {

using namespace simdjson::arm64;

template <>

struct utf8_checker<Architecture::ARM64> {

int8x16_t has_error{};

processed_utf_bytes previous{};

really_inline void check_next_input(simd_input<Architecture::ARM64> in) {

if (check_ascii_neon(in)) {

// All bytes are ascii. Therefore the byte that was just before must be

// ascii too. We only check the byte that was just before simd_input. Nines

// are arbitrary values.

const int8x16_t verror =

(int8x16_t){9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1};

this->has_error =

vorrq_s8(vreinterpretq_s8_u8(

vcgtq_s8(this->previous.carried_continuations, verror)),

this->has_error);

} else {

// it is not ascii so we have to do heavy work

this->previous = check_utf8_bytes(vreinterpretq_s8_u8(in.i0),

&(this->previous), &(this->has_error));

this->previous = check_utf8_bytes(vreinterpretq_s8_u8(in.i1),

&(this->previous), &(this->has_error));

this->previous = check_utf8_bytes(vreinterpretq_s8_u8(in.i2),

&(this->previous), &(this->has_error));

this->previous = check_utf8_bytes(vreinterpretq_s8_u8(in.i3),

&(this->previous), &(this->has_error));

}

}

really_inline ErrorValues errors() {

uint64x2_t v64 = vreinterpretq_u64_s8(this->has_error);

uint32x2_t v32 = vqmovn_u64(v64);

uint64x1_t result = vreinterpret_u64_u32(v32);

return vget_lane_u64(result, 0) != 0 ? simdjson::UTF8_ERROR

: simdjson::SUCCESS;

}

}; // struct utf8_checker

} // namespace simdjson

#endif

#endif

/* end file src/arm64/simdutf8check.h */

/* begin file src/haswell/simdutf8check.h */

#ifndef SIMDJSON_HASWELL_SIMDUTF8CHECK_H

#define SIMDJSON_HASWELL_SIMDUTF8CHECK_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