#ifndef SIMDJSON_SRC_WESTMERE_CPP

#define SIMDJSON_SRC_WESTMERE_CPP

#ifndef SIMDJSON_CONDITIONAL_INCLUDE

#include <base.h>

#endif // SIMDJSON_CONDITIONAL_INCLUDE

#include <simdjson/westmere.h>

#include <simdjson/westmere/implementation.h>

#include <simdjson/westmere/begin.h>

#include <generic/amalgamated.h>

#include <generic/stage1/amalgamated.h>

#include <generic/stage2/amalgamated.h>

//

// Stage 1

//

namespace simdjson {

namespace westmere {

simdjson_warn_unused error_code implementation::create_dom_parser_implementation(

  size_t capacity,

  size_t max_depth,

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

) const noexcept {

  dst.reset( new (std::nothrow) dom_parser_implementation() );

  if (!dst) { return MEMALLOC; }

  if (auto err = dst->set_capacity(capacity))

    return err;

  if (auto err = dst->set_max_depth(max_depth))

    return err;

  return SUCCESS;

}

namespace {

using namespace simd;

simdjson_inline json_character_block json_character_block::classify(const simd::simd8x64<uint8_t>& in) {

  // These lookups rely on the fact that anything < 127 will match the lower 4 bits, which is why

  // we can't use the generic lookup_16.

  auto whitespace_table = simd8<uint8_t>::repeat_16(' ', 100, 100, 100, 17, 100, 113, 2, 100, '\t', '\n', 112, 100, '\r', 100, 100);

  // The 6 operators (:,[]{}) have these values:

  //

  // , 2C

  // : 3A

  // [ 5B

  // { 7B

  // ] 5D

  // } 7D

  //

  // If you use | 0x20 to turn [ and ] into { and }, the lower 4 bits of each character is unique.

  // We exploit this, using a simd 4-bit lookup to tell us which character match against, and then

  // match it (against | 0x20).

  //

  // To prevent recognizing other characters, everything else gets compared with 0, which cannot

  // match due to the | 0x20.

  //

  // NOTE: Due to the | 0x20, this ALSO treats <FF> and <SUB> (control characters 0C and 1A) like ,

  // and :. This gets caught in stage 2, which checks the actual character to ensure the right

  // operators are in the right places.

  const auto op_table = simd8<uint8_t>::repeat_16(

    0, 0, 0, 0,

    0, 0, 0, 0,

    0, 0, ':', '{', // : = 3A, [ = 5B, { = 7B

    ',', '}', 0, 0  // , = 2C, ] = 5D, } = 7D

  );

  // We compute whitespace and op separately. If the code later only use one or the

  // other, given the fact that all functions are aggressively inlined, we can

  // hope that useless computations will be omitted. This is namely case when

  // minifying (we only need whitespace).

  const uint64_t whitespace = in.eq({

    _mm_shuffle_epi8(whitespace_table, in.chunks[0]),

    _mm_shuffle_epi8(whitespace_table, in.chunks[1]),

    _mm_shuffle_epi8(whitespace_table, in.chunks[2]),

    _mm_shuffle_epi8(whitespace_table, in.chunks[3])

  });

  // Turn [ and ] into { and }

  const simd8x64<uint8_t> curlified{

    in.chunks[0] | 0x20,

    in.chunks[1] | 0x20,

    in.chunks[2] | 0x20,

    in.chunks[3] | 0x20

  };

  const uint64_t op = curlified.eq({

    _mm_shuffle_epi8(op_table, in.chunks[0]),

    _mm_shuffle_epi8(op_table, in.chunks[1]),

    _mm_shuffle_epi8(op_table, in.chunks[2]),

    _mm_shuffle_epi8(op_table, in.chunks[3])

  });

    return { whitespace, op };

}

simdjson_inline bool is_ascii(const simd8x64<uint8_t>& input) {

  return input.reduce_or().is_ascii();

}

simdjson_unused simdjson_inline simd8<bool> must_be_continuation(const simd8<uint8_t> prev1, const simd8<uint8_t> prev2, const simd8<uint8_t> prev3) {

  simd8<uint8_t> is_second_byte = prev1.saturating_sub(0xc0u-1); // Only 11______ will be > 0

  simd8<uint8_t> is_third_byte  = prev2.saturating_sub(0xe0u-1); // Only 111_____ will be > 0

  simd8<uint8_t> is_fourth_byte = prev3.saturating_sub(0xf0u-1); // Only 1111____ will be > 0

  // Caller requires a bool (all 1's). All values resulting from the subtraction will be <= 64, so signed comparison is fine.

  return simd8<int8_t>(is_second_byte | is_third_byte | is_fourth_byte) > int8_t(0);

}

simdjson_inline simd8<bool> must_be_2_3_continuation(const simd8<uint8_t> prev2, const simd8<uint8_t> prev3) {

  simd8<uint8_t> is_third_byte  = prev2.saturating_sub(0xe0u-1); // Only 111_____ will be > 0

  simd8<uint8_t> is_fourth_byte = prev3.saturating_sub(0xf0u-1); // Only 1111____ will be > 0

  // Caller requires a bool (all 1's). All values resulting from the subtraction will be <= 64, so signed comparison is fine.

  return simd8<int8_t>(is_third_byte | is_fourth_byte) > int8_t(0);

}

} // unnamed namespace

} // namespace westmere

} // namespace simdjson

//

// Stage 2

//

//

// Implementation-specific overrides

//

namespace simdjson {

namespace westmere {

simdjson_warn_unused error_code implementation::minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept {

  return westmere::stage1::json_minifier::minify<64>(buf, len, dst, dst_len);

}

simdjson_warn_unused error_code dom_parser_implementation::stage1(const uint8_t *_buf, size_t _len, stage1_mode streaming) noexcept {

  this->buf = _buf;

  this->len = _len;

  return westmere::stage1::json_structural_indexer::index<64>(_buf, _len, *this, streaming);

}

simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t len) const noexcept {

  return westmere::stage1::generic_validate_utf8(buf,len);

}

simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {

  return stage2::tape_builder::parse_document<false>(*this, _doc);

}

simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {

  return stage2::tape_builder::parse_document<true>(*this, _doc);

}

simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool replacement_char) const noexcept {

  return westmere::stringparsing::parse_string(src, dst, replacement_char);

}

simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(const uint8_t *src, uint8_t *dst) const noexcept {

  return westmere::stringparsing::parse_wobbly_string(src, dst);

}

simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {

  auto error = stage1(_buf, _len, stage1_mode::regular);

  if (error) { return error; }

  return stage2(_doc);

}

} // namespace westmere

} // namespace simdjson

#include <simdjson/westmere/end.h>

#endif // SIMDJSON_SRC_WESTMERE_CPP