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

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

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

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");

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");

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

return get_active_implementation() = get_unsupported_singleton();

* The active implementation.

*/

in range 0x0000 .. 0xffff.

#include <cstdio>

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;

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

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

#if __riscv_v_intrinsic >= 11000

#define SIMDUTF_VERSION "5.2.6"

SIMDUTF_VERSION_REVISION = 6

#endif

#if defined(RUN_IN_SPIKE_SIMULATOR)

// Proxy Kernel does not implement yet hwprobe syscall

host_isa |= instruction_set::RVV;

virtual std::string name() const { return std::string(_name); }

virtual std::string description() const { return std::string(_description); }

const char* name,

const char* description,

const char* _name;

const char* _description;