xref: /third_party/node/deps/simdutf/simdutf.cpp

70   simdutf_warn_unused result validate_utf8_with_errors(const char *buf, size_t len) const noexcept final;
72   simdutf_warn_unused result validate_ascii_with_errors(const char *buf, size_t len) const noexcept final;
75   simdutf_warn_unused result validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept final;
76   simdutf_warn_unused result validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept final;
78   simdutf_warn_unused result validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept final;
84   simdutf_warn_unused result convert_utf8_to_latin1_with_errors(const char * buf, size_t len, char* latin1_buffer) const noexcept final;
88   simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
89   simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
93   simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
97   simdutf_warn_unused result convert_utf16le_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
98   simdutf_warn_unused result convert_utf16be_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
103   simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
104   simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
108   simdutf_warn_unused result convert_utf32_to_latin1_with_errors(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
111   simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
115   simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
116   simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
121   simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
122   simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
177 /* result might be undefined when input_num is zero */
327     // result it is 64 bit.
329     // when the vector register is the result of a comparison, with byte
1270   simdutf_warn_unused result validate_utf8_with_errors(const char *buf, size_t len) const noexcept final;
1272   simdutf_warn_unused result validate_ascii_with_errors(const char *buf, size_t len) const noexcept final;
1275   simdutf_warn_unused result validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept final;
1276   simdutf_warn_unused result validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept final;
1278   simdutf_warn_unused result validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept final;
1284   simdutf_warn_unused result convert_utf8_to_latin1_with_errors(const char * buf, size_t len, char* latin1_buffer) const noexcept final;
1288   simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
1289   simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
1293   simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
1297   simdutf_warn_unused result convert_utf16le_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1298   simdutf_warn_unused result convert_utf16be_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1303   simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1304   simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1308   simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1311   simdutf_warn_unused result convert_utf32_to_latin1_with_errors(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
1315   simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1316   simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1321   simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1322   simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1477   simdutf_warn_unused result validate_utf8_with_errors(const char *buf, size_t len) const noexcept final;
1479   simdutf_warn_unused result validate_ascii_with_errors(const char *buf, size_t len) const noexcept final;
1482   simdutf_warn_unused result validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept final;
1483   simdutf_warn_unused result validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept final;
1485   simdutf_warn_unused result validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept final;
1491   simdutf_warn_unused result convert_utf8_to_latin1_with_errors(const char * buf, size_t len, char* latin1_buffer) const noexcept final;
1495   simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
1496   simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
1500   simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
1504   simdutf_warn_unused result convert_utf16le_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1505   simdutf_warn_unused result convert_utf16be_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
1510   simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1511   simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1515   simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
1518   simdutf_warn_unused result convert_utf32_to_latin1_with_errors(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
1522   simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1523   simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
1528   simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
1529   simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
2408   simdutf_warn_unused result validate_utf8_with_errors(const char *buf, size_t len) const noexcept final;
2410   simdutf_warn_unused result validate_ascii_with_errors(const char *buf, size_t len) const noexcept final;
2413   simdutf_warn_unused result validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept final;
2414   simdutf_warn_unused result validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept final;
2416   simdutf_warn_unused result validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept final;
2422   simdutf_warn_unused result convert_utf8_to_latin1_with_errors(const char * buf, size_t len, char* latin1_buffer) const noexcept final;
2426   simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
2427   simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
2431   simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
2435   simdutf_warn_unused result convert_utf16le_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
2436   simdutf_warn_unused result convert_utf16be_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
2441   simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
2442   simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
2446   simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
2449   simdutf_warn_unused result convert_utf32_to_latin1_with_errors(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
2453   simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
2454   simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
2459   simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
2460   simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
3349   simdutf_warn_unused result validate_utf8_with_errors(const char *buf, size_t len) const noexcept final;
3351   simdutf_warn_unused result validate_ascii_with_errors(const char *buf, size_t len) const noexcept final;
3354   simdutf_warn_unused result validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept final;
3355   simdutf_warn_unused result validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept final;
3357   simdutf_warn_unused result validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept final;
3360   simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
3361   simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
3365   simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
3369   simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
3370   simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
3374   simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
3378   simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
3379   simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
3384   simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
3385   simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
3563     __vector unsigned long long result;
3567     result = ((__vector unsigned long long)vec_vbpermq((__m128i)this->value,
3570     return static_cast<int>(result[1]);
3572     return static_cast<int>(result[0]);
4006   simdutf_warn_unused result validate_utf8_with_errors(const char *buf, size_t len) const noexcept final;
4008   simdutf_warn_unused result validate_ascii_with_errors(const char *buf, size_t len) const noexcept final;
4011   simdutf_warn_unused result validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept final;
4012   simdutf_warn_unused result validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept final;
4014   simdutf_warn_unused result validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept final;
4020   simdutf_warn_unused result convert_utf8_to_latin1_with_errors(const char * buf, size_t len, char* latin1_buffer) const noexcept final;
4024   simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
4025   simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final;
4029   simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char * buf, size_t len, char32_t* utf32_output) const noexcept final;
4033   simdutf_warn_unused result convert_utf16le_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
4034   simdutf_warn_unused result convert_utf16be_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) const noexcept final;
4039   simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
4040   simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) const noexcept final;
4044   simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_buffer) const noexcept final;
4047   simdutf_warn_unused result convert_utf32_to_latin1_with_errors(const char32_t * buf, size_t len, char* latin1_output) const noexcept final;
4051   simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
4052   simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) const noexcept final;
4057   simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
4058   simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) const noexcept final;
4193 inline simdutf_warn_unused result validate_with_errors(const char *buf, size_t len) noexcept {
4214       if (++pos == len) { return result(error_code::SUCCESS, len); }
4220       if (next_pos > len) { return result(error_code::TOO_SHORT, pos); }
4221       if ((data[pos + 1] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
4224       if ((code_point < 0x80) || (0x7ff < code_point)) { return result(error_code::OVERLONG, pos); }
4227       if (next_pos > len) { return result(error_code::TOO_SHORT, pos); }
4228       if ((data[pos + 1] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
4229       if ((data[pos + 2] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
4234       if ((code_point < 0x800) || (0xffff < code_point)) { return result(error_code::OVERLONG, pos);}
4235       if (0xd7ff < code_point && code_point < 0xe000) { return result(error_code::SURROGATE, pos); }
4238       if (next_pos > len) { return result(error_code::TOO_SHORT, pos); }
4239       if ((data[pos + 1] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
4240       if ((data[pos + 2] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
4241       if ((data[pos + 3] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
4246       if (code_point <= 0xffff) { return result(error_code::OVERLONG, pos); }
4247       if (0x10ffff < code_point) { return result(error_code::TOO_LARGE, pos); }
4250       if ((byte & 0b11000000) == 0b10000000) { return result(error_code::TOO_LONG, pos); }
4251       else { return result(error_code::HEADER_BITS, pos); }
4255   return result(error_code::SUCCESS, len);
4262 inline simdutf_warn_unused result rewind_and_validate_with_errors(const char *start, const char *buf, size_t len) noexcept {
4265     return result(error_code::TOO_LONG, 0);
4279   result res = validate_with_errors(buf, len + extra_len);
4366 inline simdutf_warn_unused result validate_with_errors(const char16_t *buf, size_t len) noexcept {
4372         if(pos + 1 >= len) { return result(error_code::SURROGATE, pos); }
4374         if(diff > 0x3FF) { return result(error_code::SURROGATE, pos); }
4377         if(diff2 > 0x3FF) { return result(error_code::SURROGATE, pos); }
4383   return result(error_code::SUCCESS, pos);
4548   simdutf_warn_unused result validate_utf8_with_errors(const char * buf, size_t len) const noexcept final override {
4556   simdutf_warn_unused result validate_ascii_with_errors(const char * buf, size_t len) const noexcept final override {
4568   simdutf_warn_unused result validate_utf16le_with_errors(const char16_t * buf, size_t len) const noexcept final override {
4572   simdutf_warn_unused result validate_utf16be_with_errors(const char16_t * buf, size_t len) const noexcept final override {
4580   simdutf_warn_unused result validate_utf32_with_errors(const char32_t * buf, size_t len) const noexcept final override {
4604   simdutf_warn_unused result convert_utf8_to_latin1_with_errors(const char* buf, size_t len, char* latin1_output) const noexcept  final override {
4620   simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4624   simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4640   simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char * buf, size_t len, char32_t* utf32_output) const noexcept final override {
4656   simdutf_warn_unused result convert_utf16le_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_output) const noexcept final override {
4660   simdutf_warn_unused result convert_utf16be_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_output) const noexcept final override {
4680   simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_output) const noexcept final override {
4684   simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_output) const noexcept final override {
4700   simdutf_warn_unused result convert_utf32_to_latin1_with_errors(const char32_t * buf, size_t len, char* latin1_output) const noexcept final override {
4712   simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_output) const noexcept final override {
4728   simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4732   simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_output) const noexcept final override {
4752   simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_output) const noexcept final override {
4756   simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_output) const noexcept final override {
4888   simdutf_warn_unused result validate_utf8_with_errors(const char *, size_t) const noexcept final override {
4889     return result(error_code::OTHER, 0);
4896   simdutf_warn_unused result validate_ascii_with_errors(const char *, size_t) const noexcept final override {
4897     return result(error_code::OTHER, 0);
4908   simdutf_warn_unused result validate_utf16le_with_errors(const char16_t*, size_t) const noexcept final override {
4909     return result(error_code::OTHER, 0);
4912   simdutf_warn_unused result validate_utf16be_with_errors(const char16_t*, size_t) const noexcept final override {
4913     return result(error_code::OTHER, 0);
4920   simdutf_warn_unused result validate_utf32_with_errors(const char32_t*, size_t) const noexcept final override {
4921     return result(error_code::OTHER, 0);
4944   simdutf_warn_unused result convert_utf8_to_latin1_with_errors(const char*, size_t, char*) const noexcept final override {
4945     return result(error_code::OTHER, 0);
4960   simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char*, size_t, char16_t*) const noexcept final override {
4961     return result(error_code::OTHER, 0);
4964   simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char*, size_t, char16_t*) const noexcept final override {
4965     return result(error_code::OTHER, 0);
4980   simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char*, size_t, char32_t*) const noexcept final override {
4981     return result(error_code::OTHER, 0);
4996   simdutf_warn_unused result convert_utf16le_to_latin1_with_errors(const char16_t*, size_t, char*) const noexcept final override {
4997     return result(error_code::OTHER, 0);
5000   simdutf_warn_unused result convert_utf16be_to_latin1_with_errors(const char16_t*, size_t, char*) const noexcept final override {
5001     return result(error_code::OTHER, 0);
5020   simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t*, size_t, char*) const noexcept final override {
5021     return result(error_code::OTHER, 0);
5024   simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t*, size_t, char*) const noexcept final override {
5025     return result(error_code::OTHER, 0);
5040   simdutf_warn_unused result convert_utf32_to_latin1_with_errors(const char32_t *, size_t, char* ) const noexcept final override {
5041     return result(error_code::OTHER, 0);
5052   simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t*, size_t, char*) const noexcept final override {
5053     return result(error_code::OTHER, 0);
5068   simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t*, size_t, char16_t*) const noexcept final override {
5069     return result(error_code::OTHER, 0);
5072   simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t*, size_t, char16_t*) const noexcept final override {
5073     return result(error_code::OTHER, 0);
5092   simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t*, size_t, char32_t*) const noexcept final override {
5093     return result(error_code::OTHER, 0);
5096   simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t*, size_t, char32_t*) const noexcept final override {
5097     return result(error_code::OTHER, 0);
5243 simdutf_warn_unused result validate_utf8_with_errors(const char *buf, size_t len) noexcept {
5249 simdutf_warn_unused result validate_ascii_with_errors(const char *buf, size_t len) noexcept {
5274 simdutf_warn_unused result convert_utf8_to_latin1_with_errors(const char* buf, size_t len, char* latin1_output) noexcept {
5286 simdutf_warn_unused result convert_utf8_to_utf16_with_errors(const char * input, size_t length, char16_t* utf16_output) noexcept {
5293 simdutf_warn_unused result convert_utf8_to_utf16le_with_errors(const char * input, size_t length, char16_t* utf16_output) noexcept {
5296 simdutf_warn_unused result convert_utf8_to_utf16be_with_errors(const char * input, size_t length, char16_t* utf16_output) noexcept {
5302 simdutf_warn_unused result convert_utf8_to_utf32_with_errors(const char * input, size_t length, char32_t* utf32_output) noexcept {
5318 simdutf_warn_unused result validate_utf16_with_errors(const char16_t * buf, size_t len) noexcept {
5325 simdutf_warn_unused result validate_utf16le_with_errors(const char16_t * buf, size_t len) noexcept {
5328 simdutf_warn_unused result validate_utf16be_with_errors(const char16_t * buf, size_t len) noexcept {
5334 simdutf_warn_unused result validate_utf32_with_errors(const char32_t * buf, size_t len) noexcept {
5386 simdutf_warn_unused result convert_utf16le_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) noexcept {
5389 simdutf_warn_unused result convert_utf16be_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) noexcept {
5398 simdutf_warn_unused result convert_utf16_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) noexcept {
5405 simdutf_warn_unused result convert_utf16_to_latin1_with_errors(const char16_t * buf, size_t len, char* latin1_buffer) noexcept {
5412 simdutf_warn_unused result convert_utf16le_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) noexcept {
5415 simdutf_warn_unused result convert_utf16be_to_utf8_with_errors(const char16_t * buf, size_t len, char* utf8_buffer) noexcept {
5441 simdutf_warn_unused result convert_utf32_to_utf8_with_errors(const char32_t * buf, size_t len, char* utf8_buffer) noexcept {
5463 simdutf_warn_unused result convert_utf32_to_utf16_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) noexcept {
5470 simdutf_warn_unused result convert_utf32_to_utf16le_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) noexcept {
5473 simdutf_warn_unused result convert_utf32_to_utf16be_with_errors(const char32_t * buf, size_t len, char16_t* utf16_buffer) noexcept {
5502 simdutf_warn_unused result convert_utf16_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) noexcept {
5509 simdutf_warn_unused result convert_utf16le_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) noexcept {
5512 simdutf_warn_unused result convert_utf16be_to_utf32_with_errors(const char16_t * buf, size_t len, char32_t* utf32_buffer) noexcept {
5698   simdutf_really_inline result::result() : error{error_code::SUCCESS}, count{0} {}
5700   simdutf_really_inline result::result(error_code _err, size_t _pos) : error{_err}, count{_pos} {}
10614 inline simdutf_warn_unused result validate_with_errors(const char *buf, size_t len) noexcept {
10626                 if (data[pos] >= 0b10000000) { return result(error_code::TOO_LARGE, pos); }
10632         if (data[pos] >= 0b10000000) { return result(error_code::TOO_LARGE, pos); }
10634     return result(error_code::SUCCESS, pos);
10665 inline simdutf_warn_unused result validate_with_errors(const char32_t *buf, size_t len) noexcept {
10671         return result(error_code::TOO_LARGE, pos);
10674         return result(error_code::SURROGATE, pos);
10677   return result(error_code::SUCCESS, pos);
10878 inline result convert_with_errors(const char32_t* buf, size_t len, char* utf8_output) {
10908 			if (word >= 0xD800 && word <= 0xDFFF) { return result(error_code::SURROGATE, pos); }
10916 			if (word > 0x10FFFF) { return result(error_code::TOO_LARGE, pos); }
10924   return result(error_code::SUCCESS, utf8_output - start);
11018 inline result convert_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) {
11025       if (word >= 0xD800 && word <= 0xDFFF) { return result(error_code::SURROGATE, pos); }
11030       if (word > 0x10FFFF) { return result(error_code::TOO_LARGE, pos); }
11043   return result(error_code::SUCCESS, utf16_output - start);
11197 inline result convert_with_errors(const char16_t* buf, size_t len, char* utf8_output) {
11236       if(pos + 1 >= len) { return result(error_code::SURROGATE, pos); }
11238       if(diff > 0x3FF) { return result(error_code::SURROGATE, pos); }
11241       if(diff2 > 0x3FF) { return result(error_code::SURROGATE, pos); }
11252   return result(error_code::SUCCESS, utf8_output - start);
11341 inline result convert_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) {
11354       if(diff > 0x3FF) { return result(error_code::SURROGATE, pos); }
11355       if(pos + 1 >= len) { return result(error_code::SURROGATE, pos); } // minimal bound checking
11358       if(diff2 > 0x3FF) { return result(error_code::SURROGATE, pos); }
11364   return result(error_code::SUCCESS, utf32_output - start);
11559 inline result convert_with_errors(const char* buf, size_t len, char16_t* utf16_output) {
11588       if(pos + 1 >= len) { return result(error_code::TOO_SHORT, pos); } // minimal bound checking
11589       if ((data[pos + 1] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
11592       if (code_point < 0x80 || 0x7ff < code_point) { return result(error_code::OVERLONG, pos); }
11601       if(pos + 2 >= len) { return result(error_code::TOO_SHORT, pos); } // minimal bound checking
11603       if ((data[pos + 1] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
11604       if ((data[pos + 2] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
11609       if ((code_point < 0x800) || (0xffff < code_point)) { return result(error_code::OVERLONG, pos);}
11610       if (0xd7ff < code_point && code_point < 0xe000) { return result(error_code::SURROGATE, pos); }
11618       if(pos + 3 >= len) { return result(error_code::TOO_SHORT, pos); } // minimal bound checking
11619       if ((data[pos + 1] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
11620       if ((data[pos + 2] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
11621       if ((data[pos + 3] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
11627       if (code_point <= 0xffff) { return result(error_code::OVERLONG, pos); }
11628       if (0x10ffff < code_point) { return result(error_code::TOO_LARGE, pos); }
11641       if ((leading_byte & 0b11000000) == 0b10000000) { return result(error_code::TOO_LONG, pos); }
11642       else { return result(error_code::HEADER_BITS, pos); }
11645   return result(error_code::SUCCESS, utf16_output - start);
11658  * If the error is believed to have occured prior to 'buf', the count value contain in the result
11662 inline result rewind_and_convert_with_errors(size_t prior_bytes, const char* buf, size_t len, char16_t* utf16_output) {
11681   // It is possible for this function to return a negative count in its result.
11683   // C Standard Section 4.1.5 defines size_t as an unsigned integral type of the result of the sizeof operator
11691     return result(error_code::TOO_LONG, 0-how_far_back);
11693   result res = convert_with_errors<endian>(buf, len + extra_len, utf16_output);
11854 inline result convert_with_errors(const char* buf, size_t len, char32_t* utf32_output) {
11882       if(pos + 1 >= len) { return result(error_code::TOO_SHORT, pos); } // minimal bound checking
11883       if ((data[pos + 1] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
11886       if (code_point < 0x80 || 0x7ff < code_point) { return result(error_code::OVERLONG, pos); }
11891       if(pos + 2 >= len) { return result(error_code::TOO_SHORT, pos); } // minimal bound checking
11893       if ((data[pos + 1] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
11894       if ((data[pos + 2] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
11899       if (code_point < 0x800 || 0xffff < code_point) { return result(error_code::OVERLONG, pos); }
11900       if (0xd7ff < code_point && code_point < 0xe000) { return result(error_code::SURROGATE, pos); }
11905       if(pos + 3 >= len) { return result(error_code::TOO_SHORT, pos); } // minimal bound checking
11906       if ((data[pos + 1] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos);}
11907       if ((data[pos + 2] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
11908       if ((data[pos + 3] & 0b11000000) != 0b10000000) { return result(error_code::TOO_SHORT, pos); }
11914       if (code_point <= 0xffff) { return result(error_code::OVERLONG, pos); }
11915       if (0x10ffff < code_point) { return result(error_code::TOO_LARGE, pos); }
11920       if ((leading_byte & 0b11000000) == 0b10000000) { return result(error_code::TOO_LONG, pos); }
11921       else { return result(error_code::HEADER_BITS, pos); }
11924   return result(error_code::SUCCESS, utf32_output - start);
11937  * If the error is believed to have occured prior to 'buf', the count value contain in the result
11940 inline result rewind_and_convert_with_errors(size_t prior_bytes, const char* buf, size_t len, char32_t* utf32_output) {
11957   // It is possible for this function to return a negative count in its result.
11959   // C Standard Section 4.1.5 defines size_t as an unsigned integral type of the result of the sizeof operator
11967     return result(error_code::TOO_LONG, 0-how_far_back);
11970   result res = convert_with_errors(buf, len + extra_len, utf32_output);
12063 inline result convert_with_errors(const char* buf, size_t len, char16_t* utf16_output) {
12074   return result(error_code::SUCCESS, utf16_output - start);
12170 inline result convert_with_errors(const char* buf, size_t len, char* latin_output) {
12201         return result(error_code::TOO_SHORT, pos); } // minimal bound checking
12203         return result(error_code::TOO_SHORT, pos); } // checks if the next byte is a valid continuation byte in UTF-8. A valid continuation byte starts with 10.
12207         return result(error_code::OVERLONG, pos);
12210         return result(error_code::TOO_LARGE, pos);
12216       return result(error_code::TOO_LARGE, pos);
12219       return result(error_code::TOO_LARGE, pos);
12223         return result(error_code::TOO_LONG, pos);
12226       return result(error_code::HEADER_BITS, pos);
12230   return result(error_code::SUCCESS, latin_output - start);
12234 inline result rewind_and_convert_with_errors(size_t prior_bytes, const char* buf, size_t len, char* latin1_output) {
12253   // It is possible for this function to return a negative count in its result.
12255   // C Standard Section 4.1.5 defines size_t as an unsigned integral type of the result of the sizeof operator
12263     return result(error_code::TOO_LONG, 0-how_far_back);
12265   result res = convert_with_errors(buf, len + extra_len, latin1_output);
12315 inline result convert_with_errors(const char16_t* buf, size_t len, char* latin_output) {
12347     } else { return result(error_code::TOO_LARGE, pos); }
12349   return result(error_code::SUCCESS,latin_output - start);
12386 inline result convert_with_errors(const char32_t *buf, size_t len, char *latin1_output) {
12405     } else { return result(error_code::TOO_LARGE, pos); };
12407   return result(error_code::SUCCESS, latin1_output - start);
12950 const result arm_validate_utf16_with_errors(const char16_t* input, size_t size) {
13012                 return result(error_code::SURROGATE, input - start);
13016     return result(error_code::SUCCESS, input - start);
13051 const result arm_validate_utf32le_with_errors(const char32_t* input, size_t size) {
13068             return result(error_code::TOO_LARGE, input - start);
13073             return result(error_code::SURROGATE, input - start);
13079     return result(error_code::SUCCESS, input - start);
13365       // Add magic number to finish the result
13730 std::pair<result, char*> arm_convert_utf16_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) {
13751           return std::make_pair(result(error_code::TOO_LARGE, buf - start + k), latin1_output);
13756   return std::make_pair(result(error_code::SUCCESS, buf - start), latin1_output);
14059   Returns a pair: a result struct and utf8_output.
14060   If there is an error, the count field of the result is the position of the error.
14065 std::pair<result, char*> arm_convert_utf16_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_out) {
14296           if((diff | diff2) > 0x3FF)  { return std::make_pair(result(error_code::SURROGATE, buf - start + k - 1), reinterpret_cast<char*>(utf8_output)); }
14308   return std::make_pair(result(error_code::SUCCESS, buf - start), reinterpret_cast<char*>(utf8_output));
14416   Returns a pair: a result struct and utf8_output.
14417   If there is an error, the count field of the result is the position of the error.
14422 std::pair<result, char32_t*> arm_convert_utf16_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_out) {
14461           if((diff | diff2) > 0x3FF)  { return std::make_pair(result(error_code::SURROGATE, buf - start + k - 1), reinterpret_cast<char32_t*>(utf32_output)); }
14469   return std::make_pair(result(error_code::SUCCESS, buf - start), reinterpret_cast<char32_t*>(utf32_output));
14497 std::pair<result, char*> arm_convert_utf32_to_latin1_with_errors(const char32_t* buf, size_t len, char* latin1_output) {
14522           return std::make_pair(result(error_code::TOO_LARGE, buf - start + k), latin1_output);
14527   return std::make_pair(result(error_code::SUCCESS, buf - start), latin1_output);
14765 std::pair<result, char*> arm_convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_out) {
14847           return std::make_pair(result(error_code::SURROGATE, buf - start), reinterpret_cast<char*>(utf8_output));
14980           if (word >= 0xD800 && word <= 0xDFFF) { return std::make_pair(result(error_code::SURROGATE, buf - start + k), reinterpret_cast<char*>(utf8_output)); }
14985           if (word > 0x10FFFF) { return std::make_pair(result(error_code::TOO_LARGE, buf - start + k), reinterpret_cast<char*>(utf8_output)); }
14996   return std::make_pair(result(error_code::SUCCESS, buf - start), reinterpret_cast<char*>(utf8_output));
15060 std::pair<result, char16_t*> arm_convert_utf32_to_utf16_with_errors(const char32_t* buf, size_t len, char16_t* utf16_out) {
15076         return std::make_pair(result(error_code::SURROGATE, buf - start), reinterpret_cast<char16_t*>(utf16_output));
15091           if (word >= 0xD800 && word <= 0xDFFF) { return std::make_pair(result(error_code::SURROGATE, buf - start + k), reinterpret_cast<char16_t*>(utf16_output)); }
15095           if (word > 0x10FFFF) { return std::make_pair(result(error_code::TOO_LARGE, buf - start + k), reinterpret_cast<char16_t*>(utf16_output)); }
15111   return std::make_pair(result(error_code::SUCCESS, buf - start), reinterpret_cast<char16_t*>(utf16_output));
15434 result generic_validate_utf8_with_errors(const uint8_t * input, size_t length) {
15443         result res = scalar::utf8::rewind_and_validate_with_errors(reinterpret_cast<const char*>(input), reinterpret_cast<const char*>(input + count), length - count);
15458       result res = scalar::utf8::rewind_and_validate_with_errors(reinterpret_cast<const char*>(input), reinterpret_cast<const char*>(input) + count, length - count);
15462       return result(error_code::SUCCESS, length);
15466 result generic_validate_utf8_with_errors(const char * input, size_t length) {
15492 result generic_validate_ascii_with_errors(const uint8_t * input, size_t length) {
15498       result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
15499       return result(res.error, count + res.count);
15509     result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
15510     return result(res.error, count + res.count);
15512     return result(error_code::SUCCESS, length);
15516 result generic_validate_ascii_with_errors(const char * input, size_t length) {
15803     simdutf_really_inline result convert_with_errors(const char* in, size_t size, char16_t* utf16_output) {
15842             result res = scalar::utf8_to_utf16::rewind_and_convert_with_errors<endian>(pos, in + pos, size - pos, utf16_output);
15878         result res = scalar::utf8_to_utf16::rewind_and_convert_with_errors<endian>(pos, in + pos, size - pos, utf16_output);
15885         result res = scalar::utf8_to_utf16::rewind_and_convert_with_errors<endian>(pos, in + pos, size - pos, utf16_output);
15893       return result(error_code::SUCCESS, utf16_output - start);
16154     simdutf_really_inline result convert_with_errors(const char* in, size_t size, char32_t* utf32_output) {
16191             result res = scalar::utf8_to_utf32::rewind_and_convert_with_errors(pos, in + pos, size - pos, utf32_output);
16225         result res = scalar::utf8_to_utf32::rewind_and_convert_with_errors(pos, in + pos, size - pos, utf32_output);
16230         result res = scalar::utf8_to_utf32::rewind_and_convert_with_errors(pos, in + pos, size - pos, utf32_output);
16238       return result(error_code::SUCCESS, utf32_output - start);
16552     simdutf_really_inline result convert_with_errors(const char* in, size_t size, char* latin1_output) {
16591             result res = scalar::utf8_to_latin1::rewind_and_convert_with_errors(pos, in + pos, size - pos, latin1_output);
16627         result res = scalar::utf8_to_latin1::rewind_and_convert_with_errors(pos, in + pos, size - pos, latin1_output);
16634         result res = scalar::utf8_to_latin1::rewind_and_convert_with_errors(pos, in + pos, size - pos, latin1_output);
16642       return result(error_code::SUCCESS, latin1_output - start);
16759 simdutf_warn_unused result implementation::validate_utf8_with_errors(const char *buf, size_t len) const noexcept {
16767 simdutf_warn_unused result implementation::validate_ascii_with_errors(const char *buf, size_t len) const noexcept {
16789 simdutf_warn_unused result implementation::validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept {
16790   result res = arm_validate_utf16_with_errors<endianness::LITTLE>(buf, len);
16792     result scalar_res = scalar::utf16::validate_with_errors<endianness::LITTLE>(buf + res.count, len - res.count);
16793     return result(scalar_res.error, res.count + scalar_res.count);
16799 simdutf_warn_unused result implementation::validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept {
16800   result res = arm_validate_utf16_with_errors<endianness::BIG>(buf, len);
16802     result scalar_res = scalar::utf16::validate_with_errors<endianness::BIG>(buf + res.count, len - res.count);
16803     return result(scalar_res.error, res.count + scalar_res.count);
16818 simdutf_warn_unused result implementation::validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept {
16819   result res = arm_validate_utf32le_with_errors(buf, len);
16821     result scalar_res = scalar::utf32::validate_with_errors(buf + res.count, len - res.count);
16822     return result(scalar_res.error, res.count + scalar_res.count);
16878 simdutf_warn_unused result implementation::convert_utf8_to_latin1_with_errors(const char* buf, size_t len, char* latin1_output) const noexcept {
16897 simdutf_warn_unused result implementation::convert_utf8_to_utf16le_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
16902 simdutf_warn_unused result implementation::convert_utf8_to_utf16be_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
16922 simdutf_warn_unused result implementation::convert_utf8_to_utf32_with_errors(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
16960 simdutf_warn_unused result implementation::convert_utf16le_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
16961   std::pair<result, char*> ret = arm_convert_utf16_to_latin1_with_errors<endianness::LITTLE>(buf, len, latin1_output);
16964     result scalar_res = scalar::utf16_to_latin1::convert_with_errors<endianness::LITTLE>(
16977 simdutf_warn_unused result implementation::convert_utf16be_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
16978   std::pair<result, char*> ret = arm_convert_utf16_to_latin1_with_errors<endianness::BIG>(buf, len, latin1_output);
16981     result scalar_res = scalar::utf16_to_latin1::convert_with_errors<endianness::BIG>(
17030 simdutf_warn_unused result implementation::convert_utf16le_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17032   std::pair<result, char*> ret = arm_convert_utf16_to_utf8_with_errors<endianness::LITTLE>(buf, len, utf8_output);
17035     result scalar_res = scalar::utf16_to_utf8::convert_with_errors<endianness::LITTLE>(
17048 simdutf_warn_unused result implementation::convert_utf16be_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17050   std::pair<result, char*> ret = arm_convert_utf16_to_utf8_with_errors<endianness::BIG>(buf, len, utf8_output);
17053     result scalar_res = scalar::utf16_to_utf8::convert_with_errors<endianness::BIG>(
17087 simdutf_warn_unused result implementation::convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
17089   std::pair<result, char*> ret = arm_convert_utf32_to_utf8_with_errors(buf, len, utf8_output);
17091     result scalar_res = scalar::utf32_to_utf8::convert_with_errors(
17130 simdutf_warn_unused result implementation::convert_utf16le_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17132   std::pair<result, char32_t*> ret = arm_convert_utf16_to_utf32_with_errors<endianness::LITTLE>(buf, len, utf32_output);
17135     result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::LITTLE>(
17148 simdutf_warn_unused result implementation::convert_utf16be_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17150   std::pair<result, char32_t*> ret = arm_convert_utf16_to_utf32_with_errors<endianness::BIG>(buf, len, utf32_output);
17153     result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::BIG>(
17180 simdutf_warn_unused result implementation::convert_utf32_to_latin1_with_errors(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
17181   std::pair<result, char*> ret = arm_convert_utf32_to_latin1_with_errors(buf, len, latin1_output);
17184     result scalar_res = scalar::utf32_to_latin1::convert_with_errors(
17241 simdutf_warn_unused result implementation::convert_utf32_to_utf16le_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17243   std::pair<result, char16_t*> ret = arm_convert_utf32_to_utf16_with_errors<endianness::LITTLE>(buf, len, utf16_output);
17245     result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::LITTLE>(
17258 simdutf_warn_unused result implementation::convert_utf32_to_utf16be_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17260   std::pair<result, char16_t*> ret = arm_convert_utf32_to_utf16_with_errors<endianness::BIG>(buf, len, utf16_output);
17262     result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::BIG>(
17323   uint64_t result = 0;
17334     result -= vaddvq_s8(vreinterpretq_s8_u8(withhighbit));
17336   return result + (length / lanes) * lanes + scalar::latin1::utf8_length_from_latin1((const char*)simd_end, rem);
17466 simdutf_warn_unused result implementation::validate_utf8_with_errors(const char *buf, size_t len) const noexcept {
17474 simdutf_warn_unused result implementation::validate_ascii_with_errors(const char *buf, size_t len) const noexcept {
17486 simdutf_warn_unused result implementation::validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept {
17490 simdutf_warn_unused result implementation::validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept {
17498 simdutf_warn_unused result implementation::validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept {
17522 simdutf_warn_unused result implementation::convert_utf8_to_latin1_with_errors(const char* buf, size_t len, char* latin1_output) const noexcept {
17538 simdutf_warn_unused result implementation::convert_utf8_to_utf16le_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
17542 simdutf_warn_unused result implementation::convert_utf8_to_utf16be_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
17558 simdutf_warn_unused result implementation::convert_utf8_to_utf32_with_errors(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
17575 simdutf_warn_unused result implementation::convert_utf16le_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
17579 simdutf_warn_unused result implementation::convert_utf16be_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
17599 simdutf_warn_unused result implementation::convert_utf16le_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17603 simdutf_warn_unused result implementation::convert_utf16be_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
17619 simdutf_warn_unused result implementation::convert_utf32_to_latin1_with_errors(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
17631 simdutf_warn_unused result implementation::convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
17647 simdutf_warn_unused result implementation::convert_utf32_to_utf16le_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17651 simdutf_warn_unused result implementation::convert_utf32_to_utf16be_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
17671 simdutf_warn_unused result implementation::convert_utf16le_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17675 simdutf_warn_unused result implementation::convert_utf16be_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
17803     Returns true when the result is correct, otherwise it returns false.
18871   bool result = true;
18872   while (result) {
18874         result = process_block_utf8_to_utf16<SIMDUTF_FULL, big_endian>(in, out, final_in - in);
18876         result = process_block_utf8_to_utf16<SIMDUTF_TAIL, big_endian>(in, out, final_in - in);
18879   if(!result) { out = nullptr; }
18884 simdutf::result fast_avx512_convert_utf8_to_utf16_with_errors(const char *in, size_t len, char16_t *out) {
18888   bool  result = true;
18889   while (result) {
18891         result = process_block_utf8_to_utf16<SIMDUTF_FULL, big_endian>(in, out, final_in - in);
18893         result = process_block_utf8_to_utf16<SIMDUTF_TAIL, big_endian>(in, out, final_in - in);
18896   if(!result) {
18899     simdutf::result res = scalar::utf8_to_utf16::rewind_and_convert_with_errors<big_endian>(in - init_in, in, final_in - in, out);
18903     return simdutf::result(error_code::SUCCESS,out - init_out);
19372 std::pair<result, char *>
19398       return std::make_pair(result(error_code::TOO_LARGE, buf - start),
19421       return std::make_pair(result(error_code::TOO_LARGE, buf - start),
19428   return std::make_pair(result(error_code::SUCCESS, len), latin1_output);
19774 std::pair<result, char *>
19790       return std::make_pair(result(error_code::TOO_LARGE, buf - start),
19805       return std::make_pair(result(error_code::TOO_LARGE, buf - start),
19812   return std::make_pair(result(error_code::SUCCESS, len), latin1_output);
20059 std::pair<result, char*> avx512_convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) {
20079       return std::make_pair(result(error_code::TOO_LARGE, buf - start), utf8_output);
20159         return std::make_pair(result(error_code::SURROGATE, buf - start), utf8_output);
20281           if (word >= 0xD800 && word <= 0xDFFF) { return std::make_pair(result(error_code::SURROGATE, buf - start + k), utf8_output); }
20286           if (word > 0x10FFFF) { return std::make_pair(result(error_code::TOO_LARGE, buf - start + k), utf8_output); }
20297   return std::make_pair(result(error_code::SUCCESS, buf - start), utf8_output);
20371 std::pair<result, char16_t*> avx512_convert_utf32_to_utf16_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) {
20392         return std::make_pair(result(error_code::SURROGATE, buf - start), utf16_output);
20411           if (word >= 0xD800 && word <= 0xDFFF) { return std::make_pair(result(error_code::SURROGATE, buf - start + k), utf16_output); }
20415           if (word > 0x10FFFF) { return std::make_pair(result(error_code::TOO_LARGE, buf - start + k), utf16_output); }
20431   return std::make_pair(result(error_code::SUCCESS, buf - start), utf16_output);
20805 simdutf_warn_unused result implementation::validate_utf8_with_errors(const char *buf, size_t len) const noexcept {
20815         result res = scalar::utf8::rewind_and_validate_with_errors(reinterpret_cast<const char*>(buf), reinterpret_cast<const char*>(buf + count), len - count);
20826         result res = scalar::utf8::rewind_and_validate_with_errors(reinterpret_cast<const char*>(buf), reinterpret_cast<const char*>(buf + count), len - count);
20830         return result(error_code::SUCCESS, len);
20839 simdutf_warn_unused result implementation::validate_ascii_with_errors(const char *buf, size_t len) const noexcept {
20847       return result(error_code::TOO_LARGE, buf - buf_orig + _tzcnt_u64(notascii));
20854       return result(error_code::TOO_LARGE, buf - buf_orig + _tzcnt_u64(notascii));
20857   return result(error_code::SUCCESS, len);
20949 simdutf_warn_unused result implementation::validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept {
20963           return result(error_code::SURROGATE, (buf - start_buf) + (extra_low < extra_high ? extra_low : extra_high));
20986           return result(error_code::SURROGATE, (buf - start_buf) + (extra_low < extra_high ? extra_low : extra_high));
20990     return result(error_code::SUCCESS, len);
20993 simdutf_warn_unused result implementation::validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept {
21017           return result(error_code::SURROGATE, (buf - start_buf) + (extra_low < extra_high ? extra_low : extra_high));
21040           return result(error_code::SURROGATE, (buf - start_buf) + (extra_low < extra_high ? extra_low : extra_high));
21044     return result(error_code::SUCCESS, len);
21056 simdutf_warn_unused result implementation::validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept {
21065         return result(error_code::TOO_LARGE, buf - buf_orig + _tzcnt_u32(outside_range));
21073         return result(error_code::SURROGATE, buf - buf_orig + _tzcnt_u32(surrogate_range));
21082         return result(error_code::TOO_LARGE, buf - buf_orig + _tzcnt_u32(outside_range));
21089         return result(error_code::SURROGATE, buf - buf_orig + _tzcnt_u32(surrogate_range));
21093     return result(error_code::SUCCESS, len);
21126 simdutf_warn_unused result implementation::convert_utf8_to_latin1_with_errors(const char* buf, size_t len, char* latin1_output) const noexcept {
21140   // the input buffer, length, and output buffer, and returns a result object with an error code 
21142   result res = scalar::utf8_to_latin1::convert_with_errors(buf + inlen, len - inlen, latin1_output + inlen);
21169 simdutf_warn_unused result implementation::convert_utf8_to_utf16le_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
21173 simdutf_warn_unused result implementation::convert_utf8_to_utf16be_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
21263 simdutf_warn_unused result implementation::convert_utf8_to_utf32_with_errors(const char* buf, size_t len, char32_t* utf32) const noexcept {
21270     result res = scalar::utf8_to_utf32::rewind_and_convert_with_errors(new_buf - buf, new_buf, len - (new_buf - buf), reinterpret_cast<char32_t *>(std::get<1>(ret)));
21341 simdutf_warn_unused result implementation::convert_utf16le_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
21345 simdutf_warn_unused result implementation::convert_utf16be_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
21373 simdutf_warn_unused result implementation::convert_utf16le_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
21377     result res = scalar::utf16_to_utf8::convert_with_errors<endianness::LITTLE>(buf + inlen, len - outlen, utf8_output + outlen);
21384 simdutf_warn_unused result implementation::convert_utf16be_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
21388     result res = scalar::utf16_to_utf8::convert_with_errors<endianness::BIG>(buf + inlen, len - outlen, utf8_output + outlen);
21407 simdutf_warn_unused result implementation::convert_utf32_to_latin1_with_errors(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
21429 simdutf_warn_unused result implementation::convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
21431   std::pair<result, char*> ret = icelake::avx512_convert_utf32_to_utf8_with_errors(buf, len, utf8_output);
21433     result scalar_res = scalar::utf32_to_utf8::convert_with_errors(
21476 simdutf_warn_unused result implementation::convert_utf32_to_utf16le_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
21478   std::pair<result, char16_t*> ret = avx512_convert_utf32_to_utf16_with_errors<endianness::LITTLE>(buf, len, utf16_output);
21480     result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::LITTLE>(
21493 simdutf_warn_unused result implementation::convert_utf32_to_utf16be_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
21495   std::pair<result, char16_t*> ret = avx512_convert_utf32_to_utf16_with_errors<endianness::BIG>(buf, len, utf16_output);
21497     result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::BIG>(
21544 simdutf_warn_unused result implementation::convert_utf16le_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
21547     result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::LITTLE>(
21554     result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::LITTLE>(
21564   return simdutf::result(simdutf::SUCCESS, saved_bytes);
21567 simdutf_warn_unused result implementation::convert_utf16be_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
21570     result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::BIG>(
21577     result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::BIG>(
21587   return simdutf::result(simdutf::SUCCESS, saved_bytes);
22350 const result avx2_validate_utf16_with_errors(const char16_t* input, size_t size) {
22418                 return result(error_code::SURROGATE, input - start);
22423     return result(error_code::SUCCESS, input - start);
22460 const result avx2_validate_utf32le_with_errors(const char32_t* input, size_t size) {
22477             return result(error_code::TOO_LARGE, input - start);
22482             return result(error_code::SURROGATE, input - start);
22487     return result(error_code::SUCCESS, input - start);
22979 std::pair<result, char *>
23016               result{error_code::TOO_LARGE, (size_t)(buf - start + k)},
23023   return std::make_pair(result{error_code::SUCCESS, (size_t)(buf - start)},
23318   Returns a pair: a result struct and utf8_output.
23319   If there is an error, the count field of the result is the position of the error.
23324 std::pair<result, char*> avx2_convert_utf16_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) {
23545           if((diff | diff2) > 0x3FF)  { return std::make_pair(result(error_code::SURROGATE, buf - start + k - 1), utf8_output); }
23556   return std::make_pair(result(error_code::SUCCESS, buf - start), utf8_output);
23676   Returns a pair: a result struct and utf8_output.
23677   If there is an error, the count field of the result is the position of the error.
23682 std::pair<result, char32_t*> avx2_convert_utf16_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) {
23731           if((diff | diff2) > 0x3FF)  { return std::make_pair(result(error_code::SURROGATE, buf - start + k - 1), utf32_output); }
23739   return std::make_pair(result(error_code::SUCCESS, buf - start), utf32_output);
23776     __m256i result = _mm256_or_si256(reshuffled1, reshuffled2);
23778                      _mm256_castsi256_si128(result));
23786 std::pair<result, char *>
23812                     return std::make_pair(result(error_code::TOO_LARGE, buf - start + k),
23826             __m256i result = _mm256_or_si256(reshuffled1, reshuffled2);
23827             _mm_storeu_si128((__m128i *)latin1_output, _mm256_castsi256_si128(result));
23834     return std::make_pair(result(error_code::SUCCESS, buf - start), latin1_output);
24078 std::pair<result, char*> avx2_convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) {
24098       return std::make_pair(result(error_code::TOO_LARGE, buf - start), utf8_output);
24178         return std::make_pair(result(error_code::SURROGATE, buf - start), utf8_output);
24300           if (word >= 0xD800 && word <= 0xDFFF) { return std::make_pair(result(error_code::SURROGATE, buf - start + k), utf8_output); }
24305           if (word > 0x10FFFF) { return std::make_pair(result(error_code::TOO_LARGE, buf - start + k), utf8_output); }
24316   return std::make_pair(result(error_code::SUCCESS, buf - start), utf8_output);
24387 std::pair<result, char16_t*> avx2_convert_utf32_to_utf16_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) {
24408         return std::make_pair(result(error_code::SURROGATE, buf - start), utf16_output);
24427           if (word >= 0xD800 && word <= 0xDFFF) { return std::make_pair(result(error_code::SURROGATE, buf - start + k), utf16_output); }
24431           if (word > 0x10FFFF) { return std::make_pair(result(error_code::TOO_LARGE, buf - start + k), utf16_output); }
24447   return std::make_pair(result(error_code::SUCCESS, buf - start), utf16_output);
24845 result generic_validate_utf8_with_errors(const uint8_t * input, size_t length) {
24854         result res = scalar::utf8::rewind_and_validate_with_errors(reinterpret_cast<const char*>(input), reinterpret_cast<const char*>(input + count), length - count);
24869       result res = scalar::utf8::rewind_and_validate_with_errors(reinterpret_cast<const char*>(input), reinterpret_cast<const char*>(input) + count, length - count);
24873       return result(error_code::SUCCESS, length);
24877 result generic_validate_utf8_with_errors(const char * input, size_t length) {
24903 result generic_validate_ascii_with_errors(const uint8_t * input, size_t length) {
24909       result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
24910       return result(res.error, count + res.count);
24920     result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
24921     return result(res.error, count + res.count);
24923     return result(error_code::SUCCESS, length);
24927 result generic_validate_ascii_with_errors(const char * input, size_t length) {
25214     simdutf_really_inline result convert_with_errors(const char* in, size_t size, char16_t* utf16_output) {
25253             result res = scalar::utf8_to_utf16::rewind_and_convert_with_errors<endian>(pos, in + pos, size - pos, utf16_output);
25289         result res = scalar::utf8_to_utf16::rewind_and_convert_with_errors<endian>(pos, in + pos, size - pos, utf16_output);
25296         result res = scalar::utf8_to_utf16::rewind_and_convert_with_errors<endian>(pos, in + pos, size - pos, utf16_output);
25304       return result(error_code::SUCCESS, utf16_output - start);
25565     simdutf_really_inline result convert_with_errors(const char* in, size_t size, char32_t* utf32_output) {
25602             result res = scalar::utf8_to_utf32::rewind_and_convert_with_errors(pos, in + pos, size - pos, utf32_output);
25636         result res = scalar::utf8_to_utf32::rewind_and_convert_with_errors(pos, in + pos, size - pos, utf32_output);
25641         result res = scalar::utf8_to_utf32::rewind_and_convert_with_errors(pos, in + pos, size - pos, utf32_output);
25649       return result(error_code::SUCCESS, utf32_output - start);
25965     simdutf_really_inline result convert_with_errors(const char* in, size_t size, char* latin1_output) {
26004             result res = scalar::utf8_to_latin1::rewind_and_convert_with_errors(pos, in + pos, size - pos, latin1_output);
26040         result res = scalar::utf8_to_latin1::rewind_and_convert_with_errors(pos, in + pos, size - pos, latin1_output);
26047         result res = scalar::utf8_to_latin1::rewind_and_convert_with_errors(pos, in + pos, size - pos, latin1_output);
26055       return result(error_code::SUCCESS, latin1_output - start);
26167 simdutf_warn_unused result implementation::validate_utf8_with_errors(const char *buf, size_t len) const noexcept {
26175 simdutf_warn_unused result implementation::validate_ascii_with_errors(const char *buf, size_t len) const noexcept {
26197 simdutf_warn_unused result implementation::validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept {
26198   result res = avx2_validate_utf16_with_errors<endianness::LITTLE>(buf, len);
26200     result scalar_res = scalar::utf16::validate_with_errors<endianness::LITTLE>(buf + res.count, len - res.count);
26201     return result(scalar_res.error, res.count + scalar_res.count);
26207 simdutf_warn_unused result implementation::validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept {
26208   result res = avx2_validate_utf16_with_errors<endianness::BIG>(buf, len);
26210     result scalar_res = scalar::utf16::validate_with_errors<endianness::BIG>(buf + res.count, len - res.count);
26211     return result(scalar_res.error, res.count + scalar_res.count);
26226 simdutf_warn_unused result implementation::validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept {
26227   result res = avx2_validate_utf32le_with_errors(buf, len);
26229     result scalar_res = scalar::utf32::validate_with_errors(buf + res.count, len - res.count);
26230     return result(scalar_res.error, res.count + scalar_res.count);
26293 simdutf_warn_unused result implementation::convert_utf8_to_latin1_with_errors(const char* buf, size_t len, char* latin1_output) const noexcept {
26313 simdutf_warn_unused result implementation::convert_utf8_to_utf16le_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
26318 simdutf_warn_unused result implementation::convert_utf8_to_utf16be_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
26338 simdutf_warn_unused result implementation::convert_utf8_to_utf32_with_errors(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
26375 simdutf_warn_unused result implementation::convert_utf16le_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
26376   std::pair<result, char*> ret = avx2_convert_utf16_to_latin1_with_errors<endianness::LITTLE>(buf, len, latin1_output);
26379     result scalar_res = scalar::utf16_to_latin1::convert_with_errors<endianness::LITTLE>(
26392 simdutf_warn_unused result implementation::convert_utf16be_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
26393   std::pair<result, char*> ret = avx2_convert_utf16_to_latin1_with_errors<endianness::BIG>(buf, len, latin1_output);
26396     result scalar_res = scalar::utf16_to_latin1::convert_with_errors<endianness::BIG>(
26445 simdutf_warn_unused result implementation::convert_utf16le_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
26447   std::pair<result, char*> ret = haswell::avx2_convert_utf16_to_utf8_with_errors<endianness::LITTLE>(buf, len, utf8_output);
26450     result scalar_res = scalar::utf16_to_utf8::convert_with_errors<endianness::LITTLE>(
26463 simdutf_warn_unused result implementation::convert_utf16be_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
26465   std::pair<result, char*> ret = haswell::avx2_convert_utf16_to_utf8_with_errors<endianness::BIG>(buf, len, utf8_output);
26468     result scalar_res = scalar::utf16_to_utf8::convert_with_errors<endianness::BIG>(
26515 simdutf_warn_unused result implementation::convert_utf32_to_latin1_with_errors(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
26517   std::pair<result, char*> ret = avx2_convert_utf32_to_latin1_with_errors(buf, len, latin1_output);
26519     result scalar_res = scalar::utf32_to_latin1::convert_with_errors(
26536 simdutf_warn_unused result implementation::convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
26538   std::pair<result, char*> ret = haswell::avx2_convert_utf32_to_utf8_with_errors(buf, len, utf8_output);
26540     result scalar_res = scalar::utf32_to_utf8::convert_with_errors(
26579 simdutf_warn_unused result implementation::convert_utf16le_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
26581   std::pair<result, char32_t*> ret = haswell::avx2_convert_utf16_to_utf32_with_errors<endianness::LITTLE>(buf, len, utf32_output);
26584     result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::LITTLE>(
26597 simdutf_warn_unused result implementation::convert_utf16be_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
26599   std::pair<result, char32_t*> ret = haswell::avx2_convert_utf16_to_utf32_with_errors<endianness::BIG>(buf, len, utf32_output);
26602     result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::BIG>(
26645 simdutf_warn_unused result implementation::convert_utf32_to_utf16le_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
26647   std::pair<result, char16_t*> ret = haswell::avx2_convert_utf32_to_utf16_with_errors<endianness::LITTLE>(buf, len, utf16_output);
26649     result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::LITTLE>(
26662 simdutf_warn_unused result implementation::convert_utf32_to_utf16be_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
26664   std::pair<result, char16_t*> ret = haswell::avx2_convert_utf32_to_utf16_with_errors<endianness::BIG>(buf, len, utf16_output);
26666     result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::BIG>(
27217 result generic_validate_utf8_with_errors(const uint8_t * input, size_t length) {
27226         result res = scalar::utf8::rewind_and_validate_with_errors(reinterpret_cast<const char*>(input), reinterpret_cast<const char*>(input + count), length - count);
27241       result res = scalar::utf8::rewind_and_validate_with_errors(reinterpret_cast<const char*>(input), reinterpret_cast<const char*>(input) + count, length - count);
27245       return result(error_code::SUCCESS, length);
27249 result generic_validate_utf8_with_errors(const char * input, size_t length) {
27275 result generic_validate_ascii_with_errors(const uint8_t * input, size_t length) {
27281       result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
27282       return result(res.error, count + res.count);
27292     result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
27293     return result(res.error, count + res.count);
27295     return result(error_code::SUCCESS, length);
27299 result generic_validate_ascii_with_errors(const char * input, size_t length) {
27586     simdutf_really_inline result convert_with_errors(const char* in, size_t size, char16_t* utf16_output) {
27625             result res = scalar::utf8_to_utf16::rewind_and_convert_with_errors<endian>(pos, in + pos, size - pos, utf16_output);
27661         result res = scalar::utf8_to_utf16::rewind_and_convert_with_errors<endian>(pos, in + pos, size - pos, utf16_output);
27668         result res = scalar::utf8_to_utf16::rewind_and_convert_with_errors<endian>(pos, in + pos, size - pos, utf16_output);
27676       return result(error_code::SUCCESS, utf16_output - start);
27937     simdutf_really_inline result convert_with_errors(const char* in, size_t size, char32_t* utf32_output) {
27974             result res = scalar::utf8_to_utf32::rewind_and_convert_with_errors(pos, in + pos, size - pos, utf32_output);
28008         result res = scalar::utf8_to_utf32::rewind_and_convert_with_errors(pos, in + pos, size - pos, utf32_output);
28013         result res = scalar::utf8_to_utf32::rewind_and_convert_with_errors(pos, in + pos, size - pos, utf32_output);
28021       return result(error_code::SUCCESS, utf32_output - start);
28166 simdutf_warn_unused result implementation::validate_utf8_with_errors(const char *buf, size_t len) const noexcept {
28174 simdutf_warn_unused result implementation::validate_ascii_with_errors(const char *buf, size_t len) const noexcept {
28186 simdutf_warn_unused result implementation::validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept {
28190 simdutf_warn_unused result implementation::validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept {
28194 simdutf_warn_unused result implementation::validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept {
28210 simdutf_warn_unused result implementation::convert_utf8_to_utf16le_with_errors(const char* /*buf*/, size_t /*len*/, char16_t* /*utf16_output*/) const noexcept {
28211   return result(error_code::OTHER, 0); // stub
28214 simdutf_warn_unused result implementation::convert_utf8_to_utf16be_with_errors(const char* /*buf*/, size_t /*len*/, char16_t* /*utf16_output*/) const noexcept {
28215   return result(error_code::OTHER, 0); // stub
28230 simdutf_warn_unused result implementation::convert_utf8_to_utf32_with_errors(const char* /*buf*/, size_t /*len*/, char32_t* /*utf16_output*/) const noexcept {
28231   return result(error_code::OTHER, 0); // stub
28246 simdutf_warn_unused result implementation::convert_utf16le_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
28250 simdutf_warn_unused result implementation::convert_utf16be_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
28266 simdutf_warn_unused result implementation::convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
28282 simdutf_warn_unused result implementation::convert_utf32_to_utf16le_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
28286 simdutf_warn_unused result implementation::convert_utf32_to_utf16be_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
28306 simdutf_warn_unused result implementation::convert_utf16le_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
28310 simdutf_warn_unused result implementation::convert_utf16be_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
28826 const result sse_validate_utf16_with_errors(const char16_t* input, size_t size) {
28894                 return result(error_code::SURROGATE, input - start);
28899     return result(error_code::SUCCESS, input - start);
28936 const result sse_validate_utf32le_with_errors(const char32_t* input, size_t size) {
28953             return result(error_code::TOO_LARGE, input - start);
28958             return result(error_code::SURROGATE, input - start);
28963     return result(error_code::SUCCESS, input - start);
29505 std::pair<result, char*> sse_convert_utf16_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) {
29529           return std::make_pair(result(error_code::TOO_LARGE, buf - start + k), latin1_output);
29535   return std::make_pair(result(error_code::SUCCESS, buf - start), latin1_output);
29791   Returns a pair: a result struct and utf8_output.
29792   If there is an error, the count field of the result is the position of the error.
29797 std::pair<result, char*> sse_convert_utf16_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) {
29978           if((diff | diff2) > 0x3FF)  { return std::make_pair(result(error_code::SURROGATE, buf - start + k - 1), utf8_output); }
29990   return std::make_pair(result(error_code::SUCCESS, buf - start), utf8_output);
30109   Returns a pair: a result struct and utf8_output.
30110   If there is an error, the count field of the result is the position of the error.
30115 std::pair<result, char32_t*> sse_convert_utf16_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) {
30164           if((diff | diff2) > 0x3FF)  { return std::make_pair(result(error_code::SURROGATE, buf - start + k - 1), utf32_output); }
30172   return std::make_pair(result(error_code::SUCCESS, buf - start), utf32_output);
30210 std::pair<result, char *>
30237           return std::make_pair(result(error_code::TOO_LARGE, buf - start + k),
30252   return std::make_pair(result(error_code::SUCCESS, buf - start),
30516 std::pair<result, char*> sse_convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) {
30539       return std::make_pair(result(error_code::TOO_LARGE, buf - start), utf8_output);
30569           return std::make_pair(result(error_code::TOO_LARGE, buf - start), utf8_output);
30647         return std::make_pair(result(error_code::SURROGATE, buf - start), utf8_output);
30750           if (word >= 0xD800 && word <= 0xDFFF) { return std::make_pair(result(error_code::SURROGATE, buf - start + k), utf8_output); }
30755           if (word > 0x10FFFF) { return std::make_pair(result(error_code::TOO_LARGE, buf- start + k), utf8_output); }
30766   return std::make_pair(result(error_code::SUCCESS, buf - start), utf8_output);
30838 std::pair<result, char16_t*> sse_convert_utf32_to_utf16_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) {
30860         return std::make_pair(result(error_code::SURROGATE, buf - start), utf16_output);
30879           if (word >= 0xD800 && word <= 0xDFFF) { return std::make_pair(result(error_code::SURROGATE, buf - start + k), utf16_output); }
30883           if (word > 0x10FFFF) { return std::make_pair(result(error_code::TOO_LARGE, buf - start + k), utf16_output); }
30899   return std::make_pair(result(error_code::SUCCESS, buf - start), utf16_output);
31224 result generic_validate_utf8_with_errors(const uint8_t * input, size_t length) {
31233         result res = scalar::utf8::rewind_and_validate_with_errors(reinterpret_cast<const char*>(input), reinterpret_cast<const char*>(input + count), length - count);
31248       result res = scalar::utf8::rewind_and_validate_with_errors(reinterpret_cast<const char*>(input), reinterpret_cast<const char*>(input) + count, length - count);
31252       return result(error_code::SUCCESS, length);
31256 result generic_validate_utf8_with_errors(const char * input, size_t length) {
31282 result generic_validate_ascii_with_errors(const uint8_t * input, size_t length) {
31288       result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
31289       return result(res.error, count + res.count);
31299     result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
31300     return result(res.error, count + res.count);
31302     return result(error_code::SUCCESS, length);
31306 result generic_validate_ascii_with_errors(const char * input, size_t length) {
31593     simdutf_really_inline result convert_with_errors(const char* in, size_t size, char16_t* utf16_output) {
31632             result res = scalar::utf8_to_utf16::rewind_and_convert_with_errors<endian>(pos, in + pos, size - pos, utf16_output);
31668         result res = scalar::utf8_to_utf16::rewind_and_convert_with_errors<endian>(pos, in + pos, size - pos, utf16_output);
31675         result res = scalar::utf8_to_utf16::rewind_and_convert_with_errors<endian>(pos, in + pos, size - pos, utf16_output);
31683       return result(error_code::SUCCESS, utf16_output - start);
31944     simdutf_really_inline result convert_with_errors(const char* in, size_t size, char32_t* utf32_output) {
31981             result res = scalar::utf8_to_utf32::rewind_and_convert_with_errors(pos, in + pos, size - pos, utf32_output);
32015         result res = scalar::utf8_to_utf32::rewind_and_convert_with_errors(pos, in + pos, size - pos, utf32_output);
32020         result res = scalar::utf8_to_utf32::rewind_and_convert_with_errors(pos, in + pos, size - pos, utf32_output);
32028       return result(error_code::SUCCESS, utf32_output - start);
32342     simdutf_really_inline result convert_with_errors(const char* in, size_t size, char* latin1_output) {
32381             result res = scalar::utf8_to_latin1::rewind_and_convert_with_errors(pos, in + pos, size - pos, latin1_output);
32417         result res = scalar::utf8_to_latin1::rewind_and_convert_with_errors(pos, in + pos, size - pos, latin1_output);
32424         result res = scalar::utf8_to_latin1::rewind_and_convert_with_errors(pos, in + pos, size - pos, latin1_output);
32432       return result(error_code::SUCCESS, latin1_output - start);
32549 simdutf_warn_unused result implementation::validate_utf8_with_errors(const char *buf, size_t len) const noexcept {
32557 simdutf_warn_unused result implementation::validate_ascii_with_errors(const char *buf, size_t len) const noexcept {
32579 simdutf_warn_unused result implementation::validate_utf16le_with_errors(const char16_t *buf, size_t len) const noexcept {
32580   result res = sse_validate_utf16_with_errors<endianness::LITTLE>(buf, len);
32582     result scalar_res = scalar::utf16::validate_with_errors<endianness::LITTLE>(buf + res.count, len - res.count);
32583     return result(scalar_res.error, res.count + scalar_res.count);
32589 simdutf_warn_unused result implementation::validate_utf16be_with_errors(const char16_t *buf, size_t len) const noexcept {
32590   result res = sse_validate_utf16_with_errors<endianness::BIG>(buf, len);
32592     result scalar_res = scalar::utf16::validate_with_errors<endianness::BIG>(buf + res.count, len - res.count);
32593     return result(scalar_res.error, res.count + scalar_res.count);
32608 simdutf_warn_unused result implementation::validate_utf32_with_errors(const char32_t *buf, size_t len) const noexcept {
32609   result res = sse_validate_utf32le_with_errors(buf, len);
32611     result scalar_res = scalar::utf32::validate_with_errors(buf + res.count, len - res.count);
32612     return result(scalar_res.error, res.count + scalar_res.count);
32677 simdutf_warn_unused result implementation::convert_utf8_to_latin1_with_errors(const char* buf, size_t len, char* latin1_output) const noexcept {
32696 simdutf_warn_unused result implementation::convert_utf8_to_utf16le_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
32701 simdutf_warn_unused result implementation::convert_utf8_to_utf16be_with_errors(const char* buf, size_t len, char16_t* utf16_output) const noexcept {
32722 simdutf_warn_unused result implementation::convert_utf8_to_utf32_with_errors(const char* buf, size_t len, char32_t* utf32_output) const noexcept {
32760 simdutf_warn_unused result implementation::convert_utf16le_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
32761   std::pair<result, char*> ret = sse_convert_utf16_to_latin1_with_errors<endianness::LITTLE>(buf, len, latin1_output);
32764     result scalar_res = scalar::utf16_to_latin1::convert_with_errors<endianness::LITTLE>(
32777 simdutf_warn_unused result implementation::convert_utf16be_to_latin1_with_errors(const char16_t* buf, size_t len, char* latin1_output) const noexcept {
32778   std::pair<result, char*> ret = sse_convert_utf16_to_latin1_with_errors<endianness::BIG>(buf, len, latin1_output);
32781     result scalar_res = scalar::utf16_to_latin1::convert_with_errors<endianness::BIG>(
32831 simdutf_warn_unused result implementation::convert_utf16le_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
32833   std::pair<result, char*> ret = westmere::sse_convert_utf16_to_utf8_with_errors<endianness::LITTLE>(buf, len, utf8_output);
32836     result scalar_res = scalar::utf16_to_utf8::convert_with_errors<endianness::LITTLE>(
32849 simdutf_warn_unused result implementation::convert_utf16be_to_utf8_with_errors(const char16_t* buf, size_t len, char* utf8_output) const noexcept {
32851   std::pair<result, char*> ret = westmere::sse_convert_utf16_to_utf8_with_errors<endianness::BIG>(buf, len, utf8_output);
32854     result scalar_res = scalar::utf16_to_utf8::convert_with_errors<endianness::BIG>(
32890 simdutf_warn_unused result implementation::convert_utf32_to_latin1_with_errors(const char32_t* buf, size_t len, char* latin1_output) const noexcept {
32892   std::pair<result, char*> ret = westmere::sse_convert_utf32_to_latin1_with_errors(buf, len, latin1_output);
32894     result scalar_res = scalar::utf32_to_latin1::convert_with_errors(
32925 simdutf_warn_unused result implementation::convert_utf32_to_utf8_with_errors(const char32_t* buf, size_t len, char* utf8_output) const noexcept {
32927   std::pair<result, char*> ret = westmere::sse_convert_utf32_to_utf8_with_errors(buf, len, utf8_output);
32929     result scalar_res = scalar::utf32_to_utf8::convert_with_errors(
32968 simdutf_warn_unused result implementation::convert_utf16le_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
32970   std::pair<result, char32_t*> ret = westmere::sse_convert_utf16_to_utf32_with_errors<endianness::LITTLE>(buf, len, utf32_output);
32973     result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::LITTLE>(
32986 simdutf_warn_unused result implementation::convert_utf16be_to_utf32_with_errors(const char16_t* buf, size_t len, char32_t* utf32_output) const noexcept {
32988   std::pair<result, char32_t*> ret = westmere::sse_convert_utf16_to_utf32_with_errors<endianness::BIG>(buf, len, utf32_output);
32991     result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::BIG>(
33034 simdutf_warn_unused result implementation::convert_utf32_to_utf16le_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
33036   std::pair<result, char16_t*> ret = westmere::sse_convert_utf32_to_utf16_with_errors<endianness::LITTLE>(buf, len, utf16_output);
33038     result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::LITTLE>(
33051 simdutf_warn_unused result implementation::convert_utf32_to_utf16be_with_errors(const char32_t* buf, size_t len, char16_t* utf16_output) const noexcept {
33053   std::pair<result, char16_t*> ret = westmere::sse_convert_utf32_to_utf16_with_errors<endianness::BIG>(buf, len, utf16_output);
33055     result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::BIG>(

Indexes created Thu Nov 07 10:32:03 CST 2024