/* auto-generated on Fri Jul 17 14:52:28 EDT 2020. Do not edit! */

/* begin file src/simdjson.cpp */

#include "simdjson.h"

SIMDJSON_PUSH_DISABLE_WARNINGS

SIMDJSON_DISABLE_UNDESIRED_WARNINGS

/* begin file src/error.cpp */

namespace simdjson {

namespace internal {

SIMDJSON_DLLIMPORTEXPORT const error_code_info error_codes[] {

{ SUCCESS, "No error" },

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

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

{ TAPE_ERROR, "The JSON document has an improper structure: missing or superfluous commas, braces, missing keys, etc." },

{ DEPTH_ERROR, "The JSON document was too deep (too many nested objects and arrays)" },

{ 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" },

{ UNINITIALIZED, "Uninitialized" },

{ EMPTY, "Empty: no JSON found" },

{ UNESCAPED_CHARS, "Within strings, some characters must be escaped, we found unescaped characters" },

{ UNCLOSED_STRING, "A string is opened, but never closed." },

{ UNSUPPORTED_ARCHITECTURE, "simdjson does not have an implementation supported by this CPU architecture (perhaps it's a non-SIMD CPU?)." },

{ INCORRECT_TYPE, "The JSON element does not have the requested type." },

{ NUMBER_OUT_OF_RANGE, "The JSON number is too large or too small to fit within the requested type." },

{ INDEX_OUT_OF_BOUNDS, "Attempted to access an element of a JSON array that is beyond its length." },

{ NO_SUCH_FIELD, "The JSON field referenced does not exist in this object." },

{ IO_ERROR, "Error reading the file." },

{ INVALID_JSON_POINTER, "Invalid JSON pointer syntax." },

{ INVALID_URI_FRAGMENT, "Invalid URI fragment syntax." },

{ UNEXPECTED_ERROR, "Unexpected error, consider reporting this problem as you may have found a bug in simdjson" }

}; // error_messages[]

} // namespace internal

} // namespace simdjson

/* end file src/error.cpp */

/* begin file src/implementation.cpp */

/* begin file src/isadetection.h */

/* From

https://github.com/endorno/pytorch/blob/master/torch/lib/TH/generic/simd/simd.h

Highly modified.

Copyright (c) 2016- Facebook, Inc (Adam Paszke)

Copyright (c) 2014- Facebook, Inc (Soumith Chintala)

Copyright (c) 2011-2014 Idiap Research Institute (Ronan Collobert)

Copyright (c) 2012-2014 Deepmind Technologies (Koray Kavukcuoglu)

Copyright (c) 2011-2012 NEC Laboratories America (Koray Kavukcuoglu)

Copyright (c) 2011-2013 NYU (Clement Farabet)

Copyright (c) 2006-2010 NEC Laboratories America (Ronan Collobert, Leon Bottou,

Iain Melvin, Jason Weston) Copyright (c) 2006 Idiap Research Institute

(Samy Bengio) Copyright (c) 2001-2004 Idiap Research Institute (Ronan Collobert,

Samy Bengio, Johnny Mariethoz)

All rights reserved.

Redistribution and use in source and binary forms, with or without

modification, are permitted provided that the following conditions are met:

1. Redistributions of source code must retain the above copyright

notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright

notice, this list of conditions and the following disclaimer in the

documentation and/or other materials provided with the distribution.

3. Neither the names of Facebook, Deepmind Technologies, NYU, NEC Laboratories

America and IDIAP Research Institute nor the names of its contributors may be

used to endorse or promote products derived from this software without

specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE

LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

POSSIBILITY OF SUCH DAMAGE.

*/

#ifndef SIMDJSON_ISADETECTION_H

#define SIMDJSON_ISADETECTION_H

#include <stdint.h>

#include <stdlib.h>

#if defined(_MSC_VER)

#include <intrin.h>

#elif defined(HAVE_GCC_GET_CPUID) && defined(USE_GCC_GET_CPUID)

#include <cpuid.h>

#endif

namespace simdjson {

enum instruction_set {

DEFAULT = 0x0,

NEON = 0x1,

AVX2 = 0x4,

SSE42 = 0x8,

PCLMULQDQ = 0x10,

BMI1 = 0x20,

BMI2 = 0x40

};

#if defined(__arm__) || defined(__aarch64__) // incl. armel, armhf, arm64

#if defined(__ARM_NEON)

static inline uint32_t detect_supported_architectures() {

return instruction_set::NEON;

}

#else // ARM without NEON

static inline uint32_t detect_supported_architectures() {

return instruction_set::DEFAULT;

}

#endif

#elif defined(__x86_64__) || defined(_M_AMD64) // x64

namespace {

// Can be found on Intel ISA Reference for CPUID

constexpr uint32_t cpuid_avx2_bit = 1 << 5; ///< @private Bit 5 of EBX for EAX=0x7

constexpr uint32_t cpuid_bmi1_bit = 1 << 3; ///< @private bit 3 of EBX for EAX=0x7

constexpr uint32_t cpuid_bmi2_bit = 1 << 8; ///< @private bit 8 of EBX for EAX=0x7

constexpr uint32_t cpuid_sse42_bit = 1 << 20; ///< @private bit 20 of ECX for EAX=0x1

constexpr uint32_t cpuid_pclmulqdq_bit = 1 << 1; ///< @private bit 1 of ECX for EAX=0x1

}

static inline void cpuid(uint32_t *eax, uint32_t *ebx, uint32_t *ecx,

uint32_t *edx) {

#if defined(_MSC_VER)

int cpu_info[4];

__cpuid(cpu_info, *eax);

*eax = cpu_info[0];

*ebx = cpu_info[1];

*ecx = cpu_info[2];

*edx = cpu_info[3];

#elif defined(HAVE_GCC_GET_CPUID) && defined(USE_GCC_GET_CPUID)

uint32_t level = *eax;

__get_cpuid(level, eax, ebx, ecx, edx);

#else

uint32_t a = *eax, b, c = *ecx, d;

asm volatile("cpuid\n\t" : "+a"(a), "=b"(b), "+c"(c), "=d"(d));

*eax = a;

*ebx = b;

*ecx = c;

*edx = d;

#endif

}

static inline uint32_t detect_supported_architectures() {

uint32_t eax, ebx, ecx, edx;

uint32_t host_isa = 0x0;

// ECX for EAX=0x7

eax = 0x7;

ecx = 0x0;

cpuid(&eax, &ebx, &ecx, &edx);

if (ebx & cpuid_avx2_bit) {

host_isa |= instruction_set::AVX2;

}

if (ebx & cpuid_bmi1_bit) {

host_isa |= instruction_set::BMI1;

}

if (ebx & cpuid_bmi2_bit) {

host_isa |= instruction_set::BMI2;

}

// EBX for EAX=0x1

eax = 0x1;

cpuid(&eax, &ebx, &ecx, &edx);

if (ecx & cpuid_sse42_bit) {

host_isa |= instruction_set::SSE42;

}

if (ecx & cpuid_pclmulqdq_bit) {

host_isa |= instruction_set::PCLMULQDQ;

}

return host_isa;

}

#else // fallback

static inline uint32_t detect_supported_architectures() {

return instruction_set::DEFAULT;

}

#endif // end SIMD extension detection code

} // namespace simdjson

#endif // SIMDJSON_ISADETECTION_H

/* end file src/isadetection.h */

/* begin file src/simdprune_tables.h */

#ifndef SIMDJSON_SIMDPRUNE_TABLES_H

#define SIMDJSON_SIMDPRUNE_TABLES_H

#if SIMDJSON_IMPLEMENTATION_ARM64 || SIMDJSON_IMPLEMENTATION_HASWELL || SIMDJSON_IMPLEMENTATION_WESTMERE

#include <cstdint>

namespace simdjson { // table modified and copied from

// http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetTable

static const unsigned char BitsSetTable256mul2[256] = {

0, 2, 2, 4, 2, 4, 4, 6, 2, 4, 4, 6, 4, 6, 6, 8, 2, 4, 4,

6, 4, 6, 6, 8, 4, 6, 6, 8, 6, 8, 8, 10, 2, 4, 4, 6, 4, 6,

6, 8, 4, 6, 6, 8, 6, 8, 8, 10, 4, 6, 6, 8, 6, 8, 8, 10, 6,

8, 8, 10, 8, 10, 10, 12, 2, 4, 4, 6, 4, 6, 6, 8, 4, 6, 6, 8,

6, 8, 8, 10, 4, 6, 6, 8, 6, 8, 8, 10, 6, 8, 8, 10, 8, 10, 10,

12, 4, 6, 6, 8, 6, 8, 8, 10, 6, 8, 8, 10, 8, 10, 10, 12, 6, 8,

8, 10, 8, 10, 10, 12, 8, 10, 10, 12, 10, 12, 12, 14, 2, 4, 4, 6, 4,

6, 6, 8, 4, 6, 6, 8, 6, 8, 8, 10, 4, 6, 6, 8, 6, 8, 8, 10,

6, 8, 8, 10, 8, 10, 10, 12, 4, 6, 6, 8, 6, 8, 8, 10, 6, 8, 8,

10, 8, 10, 10, 12, 6, 8, 8, 10, 8, 10, 10, 12, 8, 10, 10, 12, 10, 12,

12, 14, 4, 6, 6, 8, 6, 8, 8, 10, 6, 8, 8, 10, 8, 10, 10, 12, 6,

8, 8, 10, 8, 10, 10, 12, 8, 10, 10, 12, 10, 12, 12, 14, 6, 8, 8, 10,

8, 10, 10, 12, 8, 10, 10, 12, 10, 12, 12, 14, 8, 10, 10, 12, 10, 12, 12,

14, 10, 12, 12, 14, 12, 14, 14, 16};

static const uint8_t pshufb_combine_table[272] = {

0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,

0x0c, 0x0d, 0x0e, 0x0f, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,

0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x80, 0x00, 0x01, 0x02, 0x03,

0x04, 0x05, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x80, 0x80,

0x00, 0x01, 0x02, 0x03, 0x04, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,

0x0f, 0x80, 0x80, 0x80, 0x00, 0x01, 0x02, 0x03, 0x08, 0x09, 0x0a, 0x0b,

0x0c, 0x0d, 0x0e, 0x0f, 0x80, 0x80, 0x80, 0x80, 0x00, 0x01, 0x02, 0x08,

0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x80, 0x80, 0x80, 0x80, 0x80,

0x00, 0x01, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x80, 0x80,

0x80, 0x80, 0x80, 0x80, 0x00, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,

0x0f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x08, 0x09, 0x0a, 0x0b,

0x0c, 0x0d, 0x0e, 0x0f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,

};

// 256 * 8 bytes = 2kB, easily fits in cache.

static const uint64_t thintable_epi8[256] = {

0x0706050403020100, 0x0007060504030201, 0x0007060504030200,

0x0000070605040302, 0x0007060504030100, 0x0000070605040301,

0x0000070605040300, 0x0000000706050403, 0x0007060504020100,

0x0000070605040201, 0x0000070605040200, 0x0000000706050402,

0x0000070605040100, 0x0000000706050401, 0x0000000706050400,

0x0000000007060504, 0x0007060503020100, 0x0000070605030201,

0x0000070605030200, 0x0000000706050302, 0x0000070605030100,

0x0000000706050301, 0x0000000706050300, 0x0000000007060503,

0x0000070605020100, 0x0000000706050201, 0x0000000706050200,

0x0000000007060502, 0x0000000706050100, 0x0000000007060501,

0x0000000007060500, 0x0000000000070605, 0x0007060403020100,

0x0000070604030201, 0x0000070604030200, 0x0000000706040302,

0x0000070604030100, 0x0000000706040301, 0x0000000706040300,

0x0000000007060403, 0x0000070604020100, 0x0000000706040201,

0x0000000706040200, 0x0000000007060402, 0x0000000706040100,

0x0000000007060401, 0x0000000007060400, 0x0000000000070604,

0x0000070603020100, 0x0000000706030201, 0x0000000706030200,

0x0000000007060302, 0x0000000706030100, 0x0000000007060301,

0x0000000007060300, 0x0000000000070603, 0x0000000706020100,

0x0000000007060201, 0x0000000007060200, 0x0000000000070602,

0x0000000007060100, 0x0000000000070601, 0x0000000000070600,

0x0000000000000706, 0x0007050403020100, 0x0000070504030201,

0x0000070504030200, 0x0000000705040302, 0x0000070504030100,

0x0000000705040301, 0x0000000705040300, 0x0000000007050403,

0x0000070504020100, 0x0000000705040201, 0x0000000705040200,

0x0000000007050402, 0x0000000705040100, 0x0000000007050401,

0x0000000007050400, 0x0000000000070504, 0x0000070503020100,

0x0000000705030201, 0x0000000705030200, 0x0000000007050302,

0x0000000705030100, 0x0000000007050301, 0x0000000007050300,

0x0000000000070503, 0x0000000705020100, 0x0000000007050201,

0x0000000007050200, 0x0000000000070502, 0x0000000007050100,

0x0000000000070501, 0x0000000000070500, 0x0000000000000705,

0x0000070403020100, 0x0000000704030201, 0x0000000704030200,

0x0000000007040302, 0x0000000704030100, 0x0000000007040301,

0x0000000007040300, 0x0000000000070403, 0x0000000704020100,

0x0000000007040201, 0x0000000007040200, 0x0000000000070402,

0x0000000007040100, 0x0000000000070401, 0x0000000000070400,

0x0000000000000704, 0x0000000703020100, 0x0000000007030201,

0x0000000007030200, 0x0000000000070302, 0x0000000007030100,

0x0000000000070301, 0x0000000000070300, 0x0000000000000703,

0x0000000007020100, 0x0000000000070201, 0x0000000000070200,

0x0000000000000702, 0x0000000000070100, 0x0000000000000701,

0x0000000000000700, 0x0000000000000007, 0x0006050403020100,

0x0000060504030201, 0x0000060504030200, 0x0000000605040302,

0x0000060504030100, 0x0000000605040301, 0x0000000605040300,

0x0000000006050403, 0x0000060504020100, 0x0000000605040201,

0x0000000605040200, 0x0000000006050402, 0x0000000605040100,

0x0000000006050401, 0x0000000006050400, 0x0000000000060504,

0x0000060503020100, 0x0000000605030201, 0x0000000605030200,

0x0000000006050302, 0x0000000605030100, 0x0000000006050301,

0x0000000006050300, 0x0000000000060503, 0x0000000605020100,

0x0000000006050201, 0x0000000006050200, 0x0000000000060502,

0x0000000006050100, 0x0000000000060501, 0x0000000000060500,

0x0000000000000605, 0x0000060403020100, 0x0000000604030201,

0x0000000604030200, 0x0000000006040302, 0x0000000604030100,

0x0000000006040301, 0x0000000006040300, 0x0000000000060403,

0x0000000604020100, 0x0000000006040201, 0x0000000006040200,

0x0000000000060402, 0x0000000006040100, 0x0000000000060401,

0x0000000000060400, 0x0000000000000604, 0x0000000603020100,

0x0000000006030201, 0x0000000006030200, 0x0000000000060302,

0x0000000006030100, 0x0000000000060301, 0x0000000000060300,

0x0000000000000603, 0x0000000006020100, 0x0000000000060201,

0x0000000000060200, 0x0000000000000602, 0x0000000000060100,

0x0000000000000601, 0x0000000000000600, 0x0000000000000006,

0x0000050403020100, 0x0000000504030201, 0x0000000504030200,

0x0000000005040302, 0x0000000504030100, 0x0000000005040301,

0x0000000005040300, 0x0000000000050403, 0x0000000504020100,

0x0000000005040201, 0x0000000005040200, 0x0000000000050402,

0x0000000005040100, 0x0000000000050401, 0x0000000000050400,

0x0000000000000504, 0x0000000503020100, 0x0000000005030201,

0x0000000005030200, 0x0000000000050302, 0x0000000005030100,

0x0000000000050301, 0x0000000000050300, 0x0000000000000503,

0x0000000005020100, 0x0000000000050201, 0x0000000000050200,

0x0000000000000502, 0x0000000000050100, 0x0000000000000501,

0x0000000000000500, 0x0000000000000005, 0x0000000403020100,

0x0000000004030201, 0x0000000004030200, 0x0000000000040302,

0x0000000004030100, 0x0000000000040301, 0x0000000000040300,

0x0000000000000403, 0x0000000004020100, 0x0000000000040201,

0x0000000000040200, 0x0000000000000402, 0x0000000000040100,

0x0000000000000401, 0x0000000000000400, 0x0000000000000004,

0x0000000003020100, 0x0000000000030201, 0x0000000000030200,

0x0000000000000302, 0x0000000000030100, 0x0000000000000301,

0x0000000000000300, 0x0000000000000003, 0x0000000000020100,

0x0000000000000201, 0x0000000000000200, 0x0000000000000002,

0x0000000000000100, 0x0000000000000001, 0x0000000000000000,

0x0000000000000000,

}; //static uint64_t thintable_epi8[256]

} // namespace simdjson

#endif // SIMDJSON_IMPLEMENTATION_ARM64 || SIMDJSON_IMPLEMENTATION_HASWELL || SIMDJSON_IMPLEMENTATION_WESTMERE

#endif // SIMDJSON_SIMDPRUNE_TABLES_H

/* end file src/simdprune_tables.h */

#include <initializer_list>

// Static array of known implementations. We're hoping these get baked into the executable

// without requiring a static initializer.

#if SIMDJSON_IMPLEMENTATION_HASWELL

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

#ifndef SIMDJSON_HASWELL_IMPLEMENTATION_H

#define SIMDJSON_HASWELL_IMPLEMENTATION_H

/* isadetection.h already included: #include "isadetection.h" */

namespace simdjson {

namespace haswell {

class implementation final : public simdjson::implementation {

public:

really_inline implementation() : simdjson::implementation(

"haswell",

"Intel/AMD AVX2",

instruction_set::AVX2 | instruction_set::PCLMULQDQ | instruction_set::BMI1 | instruction_set::BMI2

) {}

WARN_UNUSED error_code create_dom_parser_implementation(

size_t capacity,

size_t max_length,

std::unique_ptr<internal::dom_parser_implementation>& dst

) const noexcept final;

WARN_UNUSED error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;

WARN_UNUSED bool validate_utf8(const char *buf, size_t len) const noexcept final;

};

} // namespace haswell

} // namespace simdjson

#endif // SIMDJSON_HASWELL_IMPLEMENTATION_H

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

namespace simdjson { namespace internal { const haswell::implementation haswell_singleton{}; } }

#endif // SIMDJSON_IMPLEMENTATION_HASWELL

#if SIMDJSON_IMPLEMENTATION_WESTMERE

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

#ifndef SIMDJSON_WESTMERE_IMPLEMENTATION_H

#define SIMDJSON_WESTMERE_IMPLEMENTATION_H

/* isadetection.h already included: #include "isadetection.h" */

namespace simdjson {

namespace westmere {

using namespace simdjson::dom;

class implementation final : public simdjson::implementation {

public:

really_inline implementation() : simdjson::implementation("westmere", "Intel/AMD SSE4.2", instruction_set::SSE42 | instruction_set::PCLMULQDQ) {}

WARN_UNUSED error_code create_dom_parser_implementation(

size_t capacity,

size_t max_length,

std::unique_ptr<internal::dom_parser_implementation>& dst

) const noexcept final;

WARN_UNUSED error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;

WARN_UNUSED bool validate_utf8(const char *buf, size_t len) const noexcept final;

};

} // namespace westmere

} // namespace simdjson

#endif // SIMDJSON_WESTMERE_IMPLEMENTATION_H

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

namespace simdjson { namespace internal { const westmere::implementation westmere_singleton{}; } }

#endif // SIMDJSON_IMPLEMENTATION_WESTMERE

#if SIMDJSON_IMPLEMENTATION_ARM64

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

#ifndef SIMDJSON_ARM64_IMPLEMENTATION_H

#define SIMDJSON_ARM64_IMPLEMENTATION_H

/* isadetection.h already included: #include "isadetection.h" */

namespace simdjson {

namespace arm64 {

using namespace simdjson::dom;

class implementation final : public simdjson::implementation {

public:

really_inline implementation() : simdjson::implementation("arm64", "ARM NEON", instruction_set::NEON) {}

WARN_UNUSED error_code create_dom_parser_implementation(

size_t capacity,

size_t max_length,

std::unique_ptr<internal::dom_parser_implementation>& dst

) const noexcept final;

WARN_UNUSED error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;

WARN_UNUSED bool validate_utf8(const char *buf, size_t len) const noexcept final;

};

} // namespace arm64

} // namespace simdjson

#endif // SIMDJSON_ARM64_IMPLEMENTATION_H

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

namespace simdjson { namespace internal { const arm64::implementation arm64_singleton{}; } }

#endif // SIMDJSON_IMPLEMENTATION_ARM64

#if SIMDJSON_IMPLEMENTATION_FALLBACK

/* begin file src/fallback/implementation.h */

#ifndef SIMDJSON_FALLBACK_IMPLEMENTATION_H

#define SIMDJSON_FALLBACK_IMPLEMENTATION_H

/* isadetection.h already included: #include "isadetection.h" */

namespace simdjson {

namespace fallback {

using namespace simdjson::dom;

class implementation final : public simdjson::implementation {

public:

really_inline implementation() : simdjson::implementation(

"fallback",

"Generic fallback implementation",

0

) {}

WARN_UNUSED error_code create_dom_parser_implementation(

size_t capacity,

size_t max_length,

std::unique_ptr<internal::dom_parser_implementation>& dst

) const noexcept final;

WARN_UNUSED error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;

WARN_UNUSED bool validate_utf8(const char *buf, size_t len) const noexcept final;

};

} // namespace fallback

} // namespace simdjson

#endif // SIMDJSON_FALLBACK_IMPLEMENTATION_H

/* end file src/fallback/implementation.h */

namespace simdjson { namespace internal { const fallback::implementation fallback_singleton{}; } }

#endif // SIMDJSON_IMPLEMENTATION_FALLBACK

namespace simdjson {

namespace internal {

/**

* @private Detects best supported implementation on first use, and sets it

*/

class detect_best_supported_implementation_on_first_use final : public implementation {

public:

const std::string &name() const noexcept final { return set_best()->name(); }

const std::string &description() const noexcept final { return set_best()->description(); }

uint32_t required_instruction_sets() const noexcept final { return set_best()->required_instruction_sets(); }

WARN_UNUSED error_code create_dom_parser_implementation(

size_t capacity,

size_t max_length,

std::unique_ptr<internal::dom_parser_implementation>& dst

) const noexcept final {

return set_best()->create_dom_parser_implementation(capacity, max_length, dst);

}

WARN_UNUSED error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final {

return set_best()->minify(buf, len, dst, dst_len);

}

WARN_UNUSED bool validate_utf8(const char * buf, size_t len) const noexcept final override {

return set_best()->validate_utf8(buf, len);

}

really_inline detect_best_supported_implementation_on_first_use() noexcept : implementation("best_supported_detector", "Detects the best supported implementation and sets it", 0) {}

private:

const implementation *set_best() const noexcept;

};

const detect_best_supported_implementation_on_first_use detect_best_supported_implementation_on_first_use_singleton;

const std::initializer_list<const implementation *> available_implementation_pointers {

#if SIMDJSON_IMPLEMENTATION_HASWELL

&haswell_singleton,

#endif

#if SIMDJSON_IMPLEMENTATION_WESTMERE

&westmere_singleton,

#endif

#if SIMDJSON_IMPLEMENTATION_ARM64

&arm64_singleton,

#endif

#if SIMDJSON_IMPLEMENTATION_FALLBACK

&fallback_singleton,

#endif

}; // available_implementation_pointers

// So we can return UNSUPPORTED_ARCHITECTURE from the parser when there is no support

class unsupported_implementation final : public implementation {

public:

WARN_UNUSED error_code create_dom_parser_implementation(

size_t,

size_t,

std::unique_ptr<internal::dom_parser_implementation>&

) const noexcept final {

return UNSUPPORTED_ARCHITECTURE;

}

WARN_UNUSED error_code minify(const uint8_t *, size_t, uint8_t *, size_t &) const noexcept final override {

return UNSUPPORTED_ARCHITECTURE;

}

WARN_UNUSED bool validate_utf8(const char *, size_t) const noexcept final override {

return false; // Just refuse to validate. Given that we have a fallback implementation

// it seems unlikely that unsupported_implementation will ever be used. If it is used,

// then it will flag all strings as invalid. The alternative is to return an error_code

// from which the user has to figure out whether the string is valid UTF-8... which seems

// like a lot of work just to handle the very unlikely case that we have an unsupported

// implementation. And, when it does happen (that we have an unsupported implementation),

// what are the chances that the programmer has a fallback? Given that *we* provide the

// fallback, it implies that the programmer would need a fallback for our fallback.

}

unsupported_implementation() : implementation("unsupported", "Unsupported CPU (no detected SIMD instructions)", 0) {}

};

const unsupported_implementation unsupported_singleton{};

size_t available_implementation_list::size() const noexcept {

return internal::available_implementation_pointers.size();

}

const implementation * const *available_implementation_list::begin() const noexcept {

return internal::available_implementation_pointers.begin();

}

const implementation * const *available_implementation_list::end() const noexcept {

return internal::available_implementation_pointers.end();

}

const implementation *available_implementation_list::detect_best_supported() const noexcept {

// They are prelisted in priority order, so we just go down the list

uint32_t supported_instruction_sets = detect_supported_architectures();

for (const implementation *impl : internal::available_implementation_pointers) {

uint32_t required_instruction_sets = impl->required_instruction_sets();

if ((supported_instruction_sets & required_instruction_sets) == required_instruction_sets) { return impl; }

}

return &unsupported_singleton; // this should never happen?

}

const implementation *detect_best_supported_implementation_on_first_use::set_best() const noexcept {

SIMDJSON_PUSH_DISABLE_WARNINGS

SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe

char *force_implementation_name = getenv("SIMDJSON_FORCE_IMPLEMENTATION");

SIMDJSON_POP_DISABLE_WARNINGS

if (force_implementation_name) {

auto force_implementation = available_implementations[force_implementation_name];

if (force_implementation) {

return active_implementation = force_implementation;

} else {

// Note: abort() and stderr usage within the library is forbidden.

return active_implementation = &unsupported_singleton;

}

}

return active_implementation = available_implementations.detect_best_supported();

}

} // namespace internal

SIMDJSON_DLLIMPORTEXPORT const internal::available_implementation_list available_implementations{};

SIMDJSON_DLLIMPORTEXPORT internal::atomic_ptr<const implementation> active_implementation{&internal::detect_best_supported_implementation_on_first_use_singleton};

WARN_UNUSED error_code minify(const char *buf, size_t len, char *dst, size_t &dst_len) noexcept {

return active_implementation->minify((const uint8_t *)buf, len, (uint8_t *)dst, dst_len);

}

WARN_UNUSED bool validate_utf8(const char *buf, size_t len) noexcept {

return active_implementation->validate_utf8(buf, len);

}

} // namespace simdjson

/* end file src/fallback/implementation.h */

// Anything in the top level directory MUST be included outside of the #if statements

// below, or amalgamation will screw them up!

/* isadetection.h already included: #include "isadetection.h" */

/* begin file src/jsoncharutils.h */

#ifndef SIMDJSON_JSONCHARUTILS_H

#define SIMDJSON_JSONCHARUTILS_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 {

// structural chars here are

// they are { 0x7b } 0x7d : 0x3a [ 0x5b ] 0x5d , 0x2c (and NULL)

// we are also interested in the four whitespace characters

// space 0x20, linefeed 0x0a, horizontal tab 0x09 and carriage return 0x0d

// these are the chars that can follow a true/false/null or number atom

// and nothing else

const uint32_t structural_or_whitespace_or_null_negated[256] = {

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

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

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

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

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

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

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};

// return non-zero if not a structural or whitespace char

// zero otherwise

really_inline uint32_t is_not_structural_or_whitespace_or_null(uint8_t c) {

return structural_or_whitespace_or_null_negated[c];

}

const uint32_t structural_or_whitespace_negated[256] = {

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

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

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

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

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

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

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};

// return non-zero if not a structural or whitespace char

// zero otherwise

really_inline uint32_t is_not_structural_or_whitespace(uint8_t c) {

return structural_or_whitespace_negated[c];

}

const uint32_t structural_or_whitespace_or_null[256] = {

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

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

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 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, 1, 0, 1, 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, 1, 0, 1, 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, 0, 0};

really_inline uint32_t is_structural_or_whitespace_or_null(uint8_t c) {

return structural_or_whitespace_or_null[c];

}

const uint32_t structural_or_whitespace[256] = {

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

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

0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 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, 1, 0, 1, 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, 1, 0, 1, 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, 0, 0};

really_inline uint32_t is_structural_or_whitespace(uint8_t c) {

return structural_or_whitespace[c];

}

const uint32_t digit_to_val32[886] = {

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0x0, 0x1, 0x2, 0x3, 0x4, 0x5,

0x6, 0x7, 0x8, 0x9, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xa,

0xb, 0xc, 0xd, 0xe, 0xf, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xa, 0xb, 0xc, 0xd, 0xe,

0xf, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0x0, 0x10, 0x20, 0x30, 0x40, 0x50,

0x60, 0x70, 0x80, 0x90, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xa0,

0xb0, 0xc0, 0xd0, 0xe0, 0xf0, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xa0, 0xb0, 0xc0, 0xd0, 0xe0,

0xf0, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0x0, 0x100, 0x200, 0x300, 0x400, 0x500,

0x600, 0x700, 0x800, 0x900, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xa00,

0xb00, 0xc00, 0xd00, 0xe00, 0xf00, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xa00, 0xb00, 0xc00, 0xd00, 0xe00,

0xf00, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0x0, 0x1000, 0x2000, 0x3000, 0x4000, 0x5000,

0x6000, 0x7000, 0x8000, 0x9000, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xa000,

0xb000, 0xc000, 0xd000, 0xe000, 0xf000, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xa000, 0xb000, 0xc000, 0xd000, 0xe000,

0xf000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,

0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF};

// returns a value with the high 16 bits set if not valid

// otherwise returns the conversion of the 4 hex digits at src into the bottom

// 16 bits of the 32-bit return register

//

// see

// https://lemire.me/blog/2019/04/17/parsing-short-hexadecimal-strings-efficiently/

static inline uint32_t hex_to_u32_nocheck(

const uint8_t *src) { // strictly speaking, static inline is a C-ism

uint32_t v1 = digit_to_val32[630 + src[0]];

uint32_t v2 = digit_to_val32[420 + src[1]];

uint32_t v3 = digit_to_val32[210 + src[2]];

uint32_t v4 = digit_to_val32[0 + src[3]];

return v1 | v2 | v3 | v4;

}

// given a code point cp, writes to c

// the utf-8 code, outputting the length in

// bytes, if the length is zero, the code point

// is invalid

//

// This can possibly be made faster using pdep

// and clz and table lookups, but JSON documents

// have few escaped code points, and the following

// function looks cheap.

//

// Note: we assume that surrogates are treated separately

//

inline size_t codepoint_to_utf8(uint32_t cp, uint8_t *c) {

if (cp <= 0x7F) {

c[0] = uint8_t(cp);

return 1; // ascii

}

if (cp <= 0x7FF) {

c[0] = uint8_t((cp >> 6) + 192);

c[1] = uint8_t((cp & 63) + 128);

return 2; // universal plane

// Surrogates are treated elsewhere...

//} //else if (0xd800 <= cp && cp <= 0xdfff) {

// return 0; // surrogates // could put assert here

} else if (cp <= 0xFFFF) {

c[0] = uint8_t((cp >> 12) + 224);

c[1] = uint8_t(((cp >> 6) & 63) + 128);

c[2] = uint8_t((cp & 63) + 128);

return 3;

} else if (cp <= 0x10FFFF) { // if you know you have a valid code point, this

// is not needed

c[0] = uint8_t((cp >> 18) + 240);

c[1] = uint8_t(((cp >> 12) & 63) + 128);

c[2] = uint8_t(((cp >> 6) & 63) + 128);

c[3] = uint8_t((cp & 63) + 128);

return 4;

}

// will return 0 when the code point was too large.

return 0; // bad r

}

////

// The following code is used in number parsing. It is not

// properly "char utils" stuff, but we move it here so that

// it does not get copied multiple times in the binaries (once

// per instruction set).

///

constexpr int FASTFLOAT_SMALLEST_POWER = -325;

constexpr int FASTFLOAT_LARGEST_POWER = 308;

struct value128 {

uint64_t low;

uint64_t high;

};

#ifdef SIMDJSON_IS_32BITS // _umul128 for x86, arm

// this is a slow emulation routine for 32-bit

//

static inline uint64_t __emulu(uint32_t x, uint32_t y) {

return x * (uint64_t)y;

}

static inline uint64_t _umul128(uint64_t ab, uint64_t cd, uint64_t *hi) {

uint64_t ad = __emulu((uint32_t)(ab >> 32), (uint32_t)cd);

uint64_t bd = __emulu((uint32_t)ab, (uint32_t)cd);

uint64_t adbc = ad + __emulu((uint32_t)ab, (uint32_t)(cd >> 32));

uint64_t adbc_carry = !!(adbc < ad);

uint64_t lo = bd + (adbc << 32);

*hi = __emulu((uint32_t)(ab >> 32), (uint32_t)(cd >> 32)) + (adbc >> 32) +

(adbc_carry << 32) + !!(lo < bd);

return lo;

}

#endif

really_inline value128 full_multiplication(uint64_t value1, uint64_t value2) {

value128 answer;

#if defined(SIMDJSON_REGULAR_VISUAL_STUDIO) || defined(SIMDJSON_IS_32BITS)

#ifdef _M_ARM64

// ARM64 has native support for 64-bit multiplications, no need to emultate

answer.high = __umulh(value1, value2);

answer.low = value1 * value2;

#else

answer.low = _umul128(value1, value2, &answer.high); // _umul128 not available on ARM64

#endif // _M_ARM64

#else // defined(SIMDJSON_REGULAR_VISUAL_STUDIO) || defined(SIMDJSON_IS_32BITS)

__uint128_t r = ((__uint128_t)value1) * value2;

answer.low = uint64_t(r);

answer.high = uint64_t(r >> 64);

#endif

return answer;

}

// Precomputed powers of ten from 10^0 to 10^22. These

// can be represented exactly using the double type.

static const double power_of_ten[] = {

1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10, 1e11,

1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20, 1e21, 1e22};

// the mantissas of powers of ten from -308 to 308, extended out to sixty four

// bits

// This struct will likely get padded to 16 bytes.

typedef struct {

uint64_t mantissa;

int32_t exp;

} components;

// The array power_of_ten_components contain the powers of ten approximated

// as a 64-bit mantissa, with an exponent part. It goes from 10^

// FASTFLOAT_SMALLEST_POWER to

// 10^FASTFLOAT_LARGEST_POWER (inclusively). The mantissa is truncated, and

// never rounded up.

// Uses about 10KB.

static const components power_of_ten_components[] = {

{0xa5ced43b7e3e9188L, 7}, {0xcf42894a5dce35eaL, 10},

{0x818995ce7aa0e1b2L, 14}, {0xa1ebfb4219491a1fL, 17},