/* auto-generated on 2024-04-24 01:28:18 -0400. Do not edit! */

/* begin file src/simdutf.cpp */

#include "simdutf.h"

// We include base64_tables once.

*/

class detect_best_supported_implementation_on_first_use final : public implementation {

public:

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

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

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

simdutf_warn_unused int detect_encodings(const char * input, size_t length) const noexcept override {

const implementation *set_best() const noexcept;

};

static_assert(std::is_trivially_destructible<detect_best_supported_implementation_on_first_use>::value, "detect_best_supported_implementation_on_first_use should be trivially destructible");

static const std::initializer_list<const implementation *>& get_available_implementation_pointers() {

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

#if SIMDUTF_IMPLEMENTATION_ICELAKE

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

};

const unsupported_implementation* get_unsupported_singleton() {

static const unsupported_implementation unsupported_singleton{};

return &unsupported_singleton;

}

static_assert(std::is_trivially_destructible<unsupported_implementation>::value, "unsupported_singleton should be trivially destructible");

size_t available_implementation_list::size() const noexcept {

return internal::get_available_implementation_pointers().size();

uint32_t required_instruction_sets = impl->required_instruction_sets();

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

}

return get_unsupported_singleton(); // this should never happen?

}

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

return get_active_implementation() = force_implementation;

} else {

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

return get_active_implementation() = get_unsupported_singleton();

}

}

return get_active_implementation() = get_available_implementations().detect_best_supported();

}

/**

* The active implementation.

*/

SIMDUTF_DLLIMPORTEXPORT internal::atomic_ptr<const implementation>& get_active_implementation() {

#if SIMDUTF_SINGLE_IMPLEMENTATION

// skip runtime detection

1. an input register contains no surrogates and each value

is in range 0x0000 .. 0x07ff.

2. an input register contains no surrogates and values are

in range 0x0000 .. 0xffff.

3. an input register contains surrogates --- i.e. codepoints

can have 16 or 32 bits.

/* end file src/rvv/rvv_utf8_to.inl.cpp */

/* begin file src/rvv/rvv_utf16_to.inl.cpp */

#include <cstdio>

template<simdutf_ByteFlip bflip>

simdutf_really_inline static result rvv_utf16_to_latin1_with_errors(const char16_t *src, size_t len, char *dst) {

const char16_t *const beg = src;

const char16_t *const srcBeg = src;

char32_t *const dstBeg = dst;

constexpr const uint16_t ANY_SURROGATE_MASK = 0xf800;

constexpr const uint16_t ANY_SURROGATE_VALUE = 0xd800;

constexpr const uint16_t LO_SURROGATE_MASK = 0xfc00;

constexpr const uint16_t LO_SURROGATE_VALUE = 0xdc00;

constexpr const uint16_t HI_SURROGATE_MASK = 0xfc00;

constexpr const uint16_t HI_SURROGATE_VALUE = 0xd800;

uint16_t last = 0;

while (len > 0) {

size_t vl = __riscv_vsetvl_e16m2(len);

vuint16m2_t v0 = __riscv_vle16_v_u16m2((uint16_t const*)src, vl);

v0 = simdutf_byteflip<bflip>(v0, vl);

{ // check fast-path

const vuint16m2_t v = __riscv_vand_vx_u16m2(v0, ANY_SURROGATE_MASK, vl);

const vbool8_t any_surrogate = __riscv_vmseq_vx_u16m2_b8(v, ANY_SURROGATE_VALUE, vl);

if (__riscv_vfirst_m_b8(any_surrogate, vl) < 0) {

/* no surrogates */

__riscv_vse32_v_u32m4((uint32_t*)dst, __riscv_vzext_vf2_u32m4(v0, vl), vl);

len -= vl;

src += vl;

dst += vl;

continue;

}

}

if ((simdutf_byteflip<bflip>(src[0]) & LO_SURROGATE_MASK) == LO_SURROGATE_VALUE) {

return result(error_code::SURROGATE, src - srcBeg);

}

// decode surrogates

vuint16m2_t v1 = __riscv_vslide1down_vx_u16m2(v0, 0, vl);

vl = __riscv_vsetvl_e16m2(vl - 1);

if (vl == 0) {

return result(error_code::SURROGATE, src - srcBeg);

}

const vbool8_t surhi = __riscv_vmseq_vx_u16m2_b8(__riscv_vand_vx_u16m2(v0, HI_SURROGATE_MASK, vl), HI_SURROGATE_VALUE, vl);

const vbool8_t surlo = __riscv_vmseq_vx_u16m2_b8(__riscv_vand_vx_u16m2(v1, LO_SURROGATE_MASK, vl), LO_SURROGATE_VALUE, vl);

// compress everything but lo surrogates

const vbool8_t compress = __riscv_vmsne_vx_u16m2_b8(__riscv_vand_vx_u16m2(v0, LO_SURROGATE_MASK, vl), LO_SURROGATE_VALUE, vl);

{

const vbool8_t diff = __riscv_vmxor_mm_b8(surhi, surlo, vl);

const long idx = __riscv_vfirst_m_b8(diff, vl);

if (idx >= 0) {

return result(error_code::SURROGATE, src - srcBeg + idx + 1);

}

}

last = simdutf_byteflip<bflip>(src[vl]);

vuint32m4_t utf32 = __riscv_vzext_vf2_u32m4(v0, vl);

// v0 = 110110yyyyyyyyyy (0xd800 + yyyyyyyyyy) --- hi surrogate

// v1 = 110111xxxxxxxxxx (0xdc00 + xxxxxxxxxx) --- lo surrogate

// t0 = u16( 0000_00yy_yyyy_yyyy)

const vuint32m4_t t0 = __riscv_vzext_vf2_u32m4(__riscv_vand_vx_u16m2(v0, 0x03ff, vl), vl);

// t1 = u32(0000_0000_0000_yyyy_yyyy_yy00_0000_0000)

const vuint32m4_t t1 = __riscv_vsll_vx_u32m4(t0, 10, vl);

// t2 = u32(0000_0000_0000_0000_0000_00xx_xxxx_xxxx)

const vuint32m4_t t2 = __riscv_vzext_vf2_u32m4(__riscv_vand_vx_u16m2(v1, 0x03ff, vl), vl);

// t3 = u32(0000_0000_0000_yyyy_yyyy_yyxx_xxxx_xxxx)

const vuint32m4_t t3 = __riscv_vor_vv_u32m4(t1, t2, vl);

// t4 = utf32 from surrogate pairs

const vuint32m4_t t4 = __riscv_vadd_vx_u32m4(t3, 0x10000, vl);

const vuint32m4_t result = __riscv_vmerge_vvm_u32m4(utf32, t4, surhi, vl);

const vuint32m4_t comp = __riscv_vcompress_vm_u32m4(result, compress, vl);

const size_t vlOut = __riscv_vcpop_m_b8(compress, vl);

__riscv_vse32_v_u32m4((uint32_t*)dst, comp, vlOut);

len -= vl;

src += vl;

dst += vlOut;

if ((last & LO_SURROGATE_MASK) == LO_SURROGATE_VALUE) {

// last item is lo surrogate and got already consumed

len -= 1;

src += 1;

}

}

return result(error_code::SUCCESS, dst - dstBeg);

}

simdutf_warn_unused size_t implementation::convert_utf16le_to_utf32(const char16_t *src, size_t len, char32_t *dst) const noexcept {