Lines Matching defs:scalar
4116 /* begin file src/scalar/utf8.h */
4121 namespace scalar {
4326 } // namespace scalar
4330 /* end file src/scalar/utf8.h */
4331 /* begin file src/scalar/utf16.h */
4336 namespace scalar {
4451 } // namespace scalar
4455 /* end file src/scalar/utf16.h */
5612 return scalar::utf8::trim_partial_utf8(input, length);
5616 return scalar::utf16::trim_partial_utf16<BIG>(input, length);
5620 return scalar::utf16::trim_partial_utf16<LITTLE>(input, length);
10583 // The scalar routines should be included once.
10584 /* begin file src/scalar/ascii.h */
10589 namespace scalar {
10639 } // namespace scalar
10643 /* end file src/scalar/ascii.h */
10644 /* begin file src/scalar/utf32.h */
10649 namespace scalar {
10714 } // namespace scalar
10718 /* end file src/scalar/utf32.h */
10719 /* begin file src/scalar/latin1.h */
10724 namespace scalar {
10748 } // namespace scalar
10752 /* end file src/scalar/latin1.h */
10754 /* begin file src/scalar/utf32_to_utf8/valid_utf32_to_utf8.h */
10759 namespace scalar {
10815 } // namespace scalar
10819 /* end file src/scalar/utf32_to_utf8/valid_utf32_to_utf8.h */
10820 /* begin file src/scalar/utf32_to_utf8/utf32_to_utf8.h */
10825 namespace scalar {
10929 } // namespace scalar
10933 /* end file src/scalar/utf32_to_utf8/utf32_to_utf8.h */
10935 /* begin file src/scalar/utf32_to_utf16/valid_utf32_to_utf16.h */
10940 namespace scalar {
10974 } // namespace scalar
10978 /* end file src/scalar/utf32_to_utf16/valid_utf32_to_utf16.h */
10979 /* begin file src/scalar/utf32_to_utf16/utf32_to_utf16.h */
10984 namespace scalar {
11048 } // namespace scalar
11052 /* end file src/scalar/utf32_to_utf16/utf32_to_utf16.h */
11054 /* begin file src/scalar/utf16_to_utf8/valid_utf16_to_utf8.h */
11059 namespace scalar {
11123 } // namespace scalar
11127 /* end file src/scalar/utf16_to_utf8/valid_utf16_to_utf8.h */
11128 /* begin file src/scalar/utf16_to_utf8/utf16_to_utf8.h */
11133 namespace scalar {
11257 } // namespace scalar
11261 /* end file src/scalar/utf16_to_utf8/utf16_to_utf8.h */
11263 /* begin file src/scalar/utf16_to_utf32/valid_utf16_to_utf32.h */
11268 namespace scalar {
11299 } // namespace scalar
11303 /* end file src/scalar/utf16_to_utf32/valid_utf16_to_utf32.h */
11304 /* begin file src/scalar/utf16_to_utf32/utf16_to_utf32.h */
11309 namespace scalar {
11369 } // namespace scalar
11373 /* end file src/scalar/utf16_to_utf32/utf16_to_utf32.h */
11375 /* begin file src/scalar/utf8_to_utf16/valid_utf8_to_utf16.h */
11380 namespace scalar {
11454 } // namespace scalar
11458 /* end file src/scalar/utf8_to_utf16/valid_utf8_to_utf16.h */
11459 /* begin file src/scalar/utf8_to_utf16/utf8_to_utf16.h */
11464 namespace scalar {
11702 } // namespace scalar
11706 /* end file src/scalar/utf8_to_utf16/utf8_to_utf16.h */
11708 /* begin file src/scalar/utf8_to_utf32/valid_utf8_to_utf32.h */
11713 namespace scalar {
11768 } // namespace scalar
11772 /* end file src/scalar/utf8_to_utf32/valid_utf8_to_utf32.h */
11773 /* begin file src/scalar/utf8_to_utf32/utf8_to_utf32.h */
11778 namespace scalar {
11979 } // namespace scalar
11983 /* end file src/scalar/utf8_to_utf32/utf8_to_utf32.h */
11985 /* begin file src/scalar/latin1_to_utf8/latin1_to_utf8.h */
11990 namespace scalar {
12033 } // namespace scalar
12037 /* end file src/scalar/latin1_to_utf8/latin1_to_utf8.h */
12038 /* begin file src/scalar/latin1_to_utf16/latin1_to_utf16.h */
12043 namespace scalar {
12079 } // namespace scalar
12083 /* end file src/scalar/latin1_to_utf16/latin1_to_utf16.h */
12084 /* begin file src/scalar/latin1_to_utf32/latin1_to_utf32.h */
12089 namespace scalar {
12105 } // namespace scalar
12109 /* end file src/scalar/latin1_to_utf32/latin1_to_utf32.h */
12111 /* begin file src/scalar/utf8_to_latin1/utf8_to_latin1.h */
12117 namespace scalar {
12275 } // namespace scalar
12279 /* end file src/scalar/utf8_to_latin1/utf8_to_latin1.h */
12280 /* begin file src/scalar/utf16_to_latin1/utf16_to_latin1.h */
12285 namespace scalar {
12355 } // namespace scalar
12359 /* end file src/scalar/utf16_to_latin1/utf16_to_latin1.h */
12360 /* begin file src/scalar/utf32_to_latin1/utf32_to_latin1.h */
12365 namespace scalar {
12412 } // namespace scalar
12416 /* end file src/scalar/utf32_to_latin1/utf32_to_latin1.h */
12418 /* begin file src/scalar/utf8_to_latin1/valid_utf8_to_latin1.h */
12423 namespace scalar {
12475 } // namespace scalar
12479 /* end file src/scalar/utf8_to_latin1/valid_utf8_to_latin1.h */
12480 /* begin file src/scalar/utf16_to_latin1/valid_utf16_to_latin1.h */
12485 namespace scalar {
12507 } // namespace scalar
12511 /* end file src/scalar/utf16_to_latin1/valid_utf16_to_latin1.h */
12512 /* begin file src/scalar/utf32_to_latin1/valid_utf32_to_latin1.h */
12517 namespace scalar {
12550 } // namespace scalar
12554 /* end file src/scalar/utf32_to_latin1/valid_utf32_to_latin1.h */
12864 if (is_utf16 && scalar::utf16::validate<endianness::LITTLE>(reinterpret_cast<const char16_t*>(buf), (len - (buf - start))/2)) {
12871 if (vmaxvq_u32(is_zero) == 0 && scalar::utf32::validate(reinterpret_cast<const char32_t*>(buf), (len - (buf - start))/4)) {
13086 A scalar routing should carry on the conversion of the tail.
13283 // XXX: depending on the system scalar instructions might be faster.
13745 // Let us do a scalar fallback.
13747 uint16_t word = !match_system(big_endian) ? scalar::utf16::swap_bytes(buf[k]) : buf[k];
13810 A scalar routing should carry on the conversion of the tail.
14019 // Let us do a scalar fallback.
14020 // It may seem wasteful to use scalar code, but being efficient with SIMD
14026 uint16_t word = !match_system(big_endian) ? scalar::utf16::swap_bytes(buf[k]) : buf[k];
14039 uint16_t next_word = !match_system(big_endian) ? scalar::utf16::swap_bytes(buf[k + 1]) : buf[k + 1];
14062 A scalar routing should carry on the conversion of the tail if needed.
14273 // Let us do a scalar fallback.
14274 // It may seem wasteful to use scalar code, but being efficient with SIMD
14280 uint16_t word = !match_system(big_endian) ? scalar::utf16::swap_bytes(buf[k]) : buf[k];
14293 uint16_t next_word = !match_system(big_endian) ? scalar::utf16::swap_bytes(buf[k + 1]) : buf[k + 1];
14362 A scalar routing should carry on the conversion of the tail.
14387 // Let us do a scalar fallback.
14388 // It may seem wasteful to use scalar code, but being efficient with SIMD
14394 uint16_t word = !match_system(big_endian) ? scalar::utf16::swap_bytes(buf[k]) : buf[k];
14400 uint16_t next_word = !match_system(big_endian) ? scalar::utf16::swap_bytes(buf[k + 1]) : buf[k + 1];
14419 A scalar routing should carry on the conversion of the tail if needed.
14445 // Let us do a scalar fallback.
14446 // It may seem wasteful to use scalar code, but being efficient with SIMD
14452 uint16_t word = !match_system(big_endian) ? scalar::utf16::swap_bytes(buf[k]) : buf[k];
14458 uint16_t next_word = !match_system(big_endian) ? scalar::utf16::swap_bytes(buf[k + 1]) : buf[k + 1];
14516 // Let us do a scalar fallback.
14727 // Let us do a scalar fallback.
14728 // It may seem wasteful to use scalar code, but being efficient with SIMD
14966 // Let us do a scalar fallback.
14967 // It may seem wasteful to use scalar code, but being efficient with SIMD
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);
15498 result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
15509 result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
15591 utf16_output += scalar::utf8_to_utf16::convert_valid<endian>(input + pos, size - pos, utf16_output);
15795 size_t howmany = scalar::utf8_to_utf16::convert<endian>(in + pos, size - pos, 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);
15942 utf32_output += scalar::utf8_to_utf32::convert_valid(input + pos, size - pos, utf32_output);
16147 size_t howmany = scalar::utf8_to_utf32::convert(in + pos, size - pos, 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);
16269 return count + scalar::utf8::count_code_points(in + pos, size - pos);
16285 return count + scalar::utf8::utf16_length_from_utf8(in + pos, size - pos);
16308 return count + scalar::utf16::count_code_points<big_endian>(in + pos, size - pos);
16329 return count + scalar::utf16::utf8_length_from_utf16<big_endian>(in + pos, size - pos);
16348 scalar::utf16::change_endianness_utf16(in + pos, size - pos, output);
16545 size_t howmany = scalar::utf8_to_latin1::convert(in + pos, size - pos, 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);
16719 size_t howmany = scalar::utf8_to_latin1::convert_valid(in + pos, size - pos, latin1_output);
16774 return scalar::utf16::validate<endianness::LITTLE>(tail, len - (tail - buf));
16783 return scalar::utf16::validate<endianness::BIG>(tail, len - (tail - buf));
16792 result scalar_res = scalar::utf16::validate_with_errors<endianness::LITTLE>(buf + res.count, len - res.count);
16802 result scalar_res = scalar::utf16::validate_with_errors<endianness::BIG>(buf + res.count, len - res.count);
16812 return scalar::utf32::validate(tail, len - (tail - buf));
16821 result scalar_res = scalar::utf32::validate_with_errors(buf + res.count, len - res.count);
16833 const size_t scalar_converted_chars = scalar::latin1_to_utf8::convert(
16844 const size_t scalar_converted_chars = scalar::latin1_to_utf16::convert<endianness::LITTLE>(
16855 const size_t scalar_converted_chars = scalar::latin1_to_utf16::convert<endianness::BIG>(
16866 const size_t scalar_converted_chars = scalar::latin1_to_utf32::convert(
16938 const size_t scalar_saved_bytes = scalar::utf16_to_latin1::convert<endianness::LITTLE>(
16952 const size_t scalar_saved_bytes = scalar::utf16_to_latin1::convert<endianness::BIG>(
16962 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
16964 result scalar_res = scalar::utf16_to_latin1::convert_with_errors<endianness::LITTLE>(
16979 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
16981 result scalar_res = scalar::utf16_to_latin1::convert_with_errors<endianness::BIG>(
17009 const size_t scalar_saved_bytes = scalar::utf16_to_utf8::convert<endianness::LITTLE>(
17022 const size_t scalar_saved_bytes = scalar::utf16_to_utf8::convert<endianness::BIG>(
17033 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
17035 result scalar_res = scalar::utf16_to_utf8::convert_with_errors<endianness::LITTLE>(
17051 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
17053 result scalar_res = scalar::utf16_to_utf8::convert_with_errors<endianness::BIG>(
17079 const size_t scalar_saved_bytes = scalar::utf32_to_utf8::convert(
17091 result scalar_res = scalar::utf32_to_utf8::convert_with_errors(
17109 const size_t scalar_saved_bytes = scalar::utf16_to_utf32::convert<endianness::LITTLE>(
17122 const size_t scalar_saved_bytes = scalar::utf16_to_utf32::convert<endianness::BIG>(
17133 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
17135 result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::LITTLE>(
17151 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
17153 result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::BIG>(
17172 const size_t scalar_saved_bytes = scalar::utf32_to_latin1::convert(
17182 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
17184 result scalar_res = scalar::utf32_to_latin1::convert_with_errors(
17203 const size_t scalar_saved_bytes = scalar::utf32_to_latin1::convert_valid(
17220 const size_t scalar_saved_bytes = scalar::utf32_to_utf16::convert<endianness::LITTLE>(
17233 const size_t scalar_saved_bytes = scalar::utf32_to_utf16::convert<endianness::BIG>(
17245 result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::LITTLE>(
17262 result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::BIG>(
17312 return scalar::utf16::latin1_length_from_utf16(length);
17316 return scalar::utf32::latin1_length_from_utf32(length);
17336 return result + (length / lanes) * lanes + scalar::latin1::utf8_length_from_latin1((const char*)simd_end, rem);
17349 return scalar::latin1::utf16_length_from_latin1(length);
17354 return scalar::latin1::utf32_length_from_latin1(length);
17398 return count + scalar::utf32::utf8_length_from_utf32(input + pos, length - pos);
17414 return count + scalar::utf32::utf16_length_from_utf32(input + pos, length - pos);
17463 return scalar::utf8::validate(buf, len);
17467 return scalar::utf8::validate_with_errors(buf, len);
17471 return scalar::ascii::validate(buf, len);
17475 return scalar::ascii::validate_with_errors(buf, len);
17479 return scalar::utf16::validate<endianness::LITTLE>(buf, len);
17483 return scalar::utf16::validate<endianness::BIG>(buf, len);
17487 return scalar::utf16::validate_with_errors<endianness::LITTLE>(buf, len);
17491 return scalar::utf16::validate_with_errors<endianness::BIG>(buf, len);
17495 return scalar::utf32::validate(buf, len);
17499 return scalar::utf32::validate_with_errors(buf, len);
17503 return scalar::latin1_to_utf8::convert(buf,len,utf8_output);
17507 return scalar::latin1_to_utf16::convert<endianness::LITTLE>(buf, len, utf16_output);
17511 return scalar::latin1_to_utf16::convert<endianness::BIG>(buf, len, utf16_output);
17515 return scalar::latin1_to_utf32::convert(buf,len,utf32_output);
17519 return scalar::utf8_to_latin1::convert(buf, len, latin1_output);
17523 return scalar::utf8_to_latin1::convert_with_errors(buf, len, latin1_output);
17527 return scalar::utf8_to_latin1::convert_valid(buf, len, latin1_output);
17531 return scalar::utf8_to_utf16::convert<endianness::LITTLE>(buf, len, utf16_output);
17535 return scalar::utf8_to_utf16::convert<endianness::BIG>(buf, len, utf16_output);
17539 return scalar::utf8_to_utf16::convert_with_errors<endianness::LITTLE>(buf, len, utf16_output);
17543 return scalar::utf8_to_utf16::convert_with_errors<endianness::BIG>(buf, len, utf16_output);
17547 return scalar::utf8_to_utf16::convert_valid<endianness::LITTLE>(buf, len, utf16_output);
17551 return scalar::utf8_to_utf16::convert_valid<endianness::BIG>(buf, len, utf16_output);
17555 return scalar::utf8_to_utf32::convert(buf, len, utf32_output);
17559 return scalar::utf8_to_utf32::convert_with_errors(buf, len, utf32_output);
17564 return scalar::utf8_to_utf32::convert_valid(input, size, utf32_output);
17568 return scalar::utf16_to_latin1::convert<endianness::LITTLE>(buf, len, latin1_output);
17572 return scalar::utf16_to_latin1::convert<endianness::BIG>(buf, len, latin1_output);
17576 return scalar::utf16_to_latin1::convert_with_errors<endianness::LITTLE>(buf, len, latin1_output);
17580 return scalar::utf16_to_latin1::convert_with_errors<endianness::BIG>(buf, len, latin1_output);
17584 return scalar::utf16_to_latin1::convert_valid<endianness::LITTLE>(buf, len, latin1_output);
17588 return scalar::utf16_to_latin1::convert_valid<endianness::BIG>(buf, len, latin1_output);
17592 return scalar::utf16_to_utf8::convert<endianness::LITTLE>(buf, len, utf8_output);
17596 return scalar::utf16_to_utf8::convert<endianness::BIG>(buf, len, utf8_output);
17600 return scalar::utf16_to_utf8::convert_with_errors<endianness::LITTLE>(buf, len, utf8_output);
17604 return scalar::utf16_to_utf8::convert_with_errors<endianness::BIG>(buf, len, utf8_output);
17608 return scalar::utf16_to_utf8::convert_valid<endianness::LITTLE>(buf, len, utf8_output);
17612 return scalar::utf16_to_utf8::convert_valid<endianness::BIG>(buf, len, utf8_output);
17616 return scalar::utf32_to_latin1::convert(buf, len, latin1_output);
17620 return scalar::utf32_to_latin1::convert_with_errors(buf, len, latin1_output);
17624 return scalar::utf32_to_latin1::convert_valid(buf, len, latin1_output);
17628 return scalar::utf32_to_utf8::convert(buf, len, utf8_output);
17632 return scalar::utf32_to_utf8::convert_with_errors(buf, len, utf8_output);
17636 return scalar::utf32_to_utf8::convert_valid(buf, len, utf8_output);
17640 return scalar::utf32_to_utf16::convert<endianness::LITTLE>(buf, len, utf16_output);
17644 return scalar::utf32_to_utf16::convert<endianness::BIG>(buf, len, utf16_output);
17648 return scalar::utf32_to_utf16::convert_with_errors<endianness::LITTLE>(buf, len, utf16_output);
17652 return scalar::utf32_to_utf16::convert_with_errors<endianness::BIG>(buf, len, utf16_output);
17656 return scalar::utf32_to_utf16::convert_valid<endianness::LITTLE>(buf, len, utf16_output);
17660 return scalar::utf32_to_utf16::convert_valid<endianness::BIG>(buf, len, utf16_output);
17664 return scalar::utf16_to_utf32::convert<endianness::LITTLE>(buf, len, utf32_output);
17668 return scalar::utf16_to_utf32::convert<endianness::BIG>(buf, len, utf32_output);
17672 return scalar::utf16_to_utf32::convert_with_errors<endianness::LITTLE>(buf, len, utf32_output);
17676 return scalar::utf16_to_utf32::convert_with_errors<endianness::BIG>(buf, len, utf32_output);
17680 return scalar::utf16_to_utf32::convert_valid<endianness::LITTLE>(buf, len, utf32_output);
17684 return scalar::utf16_to_utf32::convert_valid<endianness::BIG>(buf, len, utf32_output);
17688 scalar::utf16::change_endianness_utf16(input, length, output);
17692 return scalar::utf16::count_code_points<endianness::LITTLE>(input, length);
17696 return scalar::utf16::count_code_points<endianness::BIG>(input, length);
17700 return scalar::utf8::count_code_points(input, length);
17704 return scalar::utf8::count_code_points(buf,len);
17708 return scalar::utf16::latin1_length_from_utf16(length);
17716 return scalar::latin1::utf8_length_from_latin1(input,length);
17720 return scalar::utf16::utf8_length_from_utf16<endianness::LITTLE>(input, length);
17724 return scalar::utf16::utf8_length_from_utf16<endianness::BIG>(input, length);
17728 return scalar::utf16::utf32_length_from_utf16<endianness::LITTLE>(input, length);
17732 return scalar::utf16::utf32_length_from_utf16<endianness::BIG>(input, length);
17736 return scalar::latin1::utf16_length_from_latin1(length);
17740 return scalar::utf8::utf16_length_from_utf8(input, length);
17744 return scalar::utf32::utf8_length_from_utf32(input, length);
17748 return scalar::utf32::utf16_length_from_utf32(input, length);
17752 return scalar::latin1::utf32_length_from_latin1(length);
17756 return scalar::utf8::count_code_points(input, length);
18899 simdutf::result res = scalar::utf8_to_utf16::rewind_and_convert_with_errors<big_endian>(in - init_in, in, final_in - in, out);
19393 while ((word = (big_endian ? scalar::utf16::swap_bytes(uint16_t(*buf))
19416 while ((word = (big_endian ? scalar::utf16::swap_bytes(uint16_t(*buf))
19635 A scalar routing should carry on the conversion of the tail.
20017 // Let us do a scalar fallback.
20018 // It may seem wasteful to use scalar code, but being efficient with SIMD
20267 // Let us do a scalar fallback.
20268 // It may seem wasteful to use scalar code, but being efficient with SIMD
20762 if (is_utf16 && scalar::utf16::validate<endianness::LITTLE>(
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);
21050 return scalar::utf32::validate(tail, len - (tail - buf));
21113 const size_t scalar_converted_chars = scalar::latin1_to_utf32::convert(
21138 // Else if there are remaining bytes, use the scalar function to process them.
21139 // Note: This is assuming scalar::utf8_to_latin1::convert_with_errors is a function that takes
21142 result res = scalar::utf8_to_latin1::convert_with_errors(buf + inlen, len - inlen, latin1_output + inlen);
21195 const size_t scalar_saved_bytes = scalar::utf8_to_utf16::convert_valid<endianness::LITTLE>(
21222 const size_t scalar_saved_bytes = scalar::utf8_to_utf16::convert_valid<endianness::BIG>(
21254 const size_t scalar_saved_bytes = scalar::utf8_to_utf32::convert(
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)));
21290 auto scalar_result = scalar::utf8_to_utf32::convert_with_errors(
21323 const size_t scalar_saved_bytes = scalar::utf8_to_utf32::convert_valid(
21377 result res = scalar::utf16_to_utf8::convert_with_errors<endianness::LITTLE>(buf + inlen, len - outlen, utf8_output + outlen);
21388 result res = scalar::utf16_to_utf8::convert_with_errors<endianness::BIG>(buf + inlen, len - outlen, utf8_output + outlen);
21421 const size_t scalar_saved_bytes = scalar::utf32_to_utf8::convert(
21433 result scalar_res = scalar::utf32_to_utf8::convert_with_errors(
21455 const size_t scalar_saved_bytes = scalar::utf32_to_utf16::convert<endianness::LITTLE>(
21468 const size_t scalar_saved_bytes = scalar::utf32_to_utf16::convert<endianness::BIG>(
21480 result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::LITTLE>(
21497 result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::BIG>(
21523 const size_t scalar_saved_bytes = scalar::utf16_to_utf32::convert<endianness::LITTLE>(
21536 const size_t scalar_saved_bytes = scalar::utf16_to_utf32::convert<endianness::BIG>(
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>(
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>(
21595 const size_t scalar_saved_bytes = scalar::utf16_to_utf32::convert<endianness::LITTLE>(
21608 const size_t scalar_saved_bytes = scalar::utf16_to_utf32::convert<endianness::BIG>(
21659 return count + scalar::utf16::count_code_points<endianness::LITTLE>(ptr, length - (ptr - input));
21687 return count + scalar::utf16::count_code_points<endianness::BIG>(ptr, length - (ptr - input));
21747 return answer + scalar::utf8::count_code_points(reinterpret_cast<const char *>(str + i), length - i);
21755 return scalar::utf16::latin1_length_from_utf16(length);
21759 return scalar::utf32::latin1_length_from_utf32(length);
21789 return count + scalar::utf16::utf8_length_from_utf16<endianness::LITTLE>(ptr, length - (ptr - input));
21828 return count + scalar::utf16::utf8_length_from_utf16<endianness::BIG>(ptr, length - (ptr - input));
21840 return scalar::latin1::utf16_length_from_latin1(length);
21845 return scalar::latin1::utf32_length_from_latin1(length);
21906 return answer + scalar::latin1::utf8_length_from_latin1(reinterpret_cast<const char *>(str + i), length - i);
21922 return count + scalar::utf8::utf16_length_from_utf8(input + pos, length - pos);
21949 return count + scalar::utf32::utf8_length_from_utf32(ptr, length - (ptr - input));
21968 return count + scalar::utf32::utf16_length_from_utf32(ptr, length - (ptr - input));
22210 if (is_utf16 && scalar::utf16::validate<endianness::LITTLE>(reinterpret_cast<const char16_t*>(buf), (len - (buf - start))/2)) {
22217 if (_mm256_testz_si256(is_zero, is_zero) == 1 && scalar::utf32::validate(reinterpret_cast<const char32_t*>(buf), (len - (buf - start))/4)) {
22269 - pointer to the last unprocessed character (a scalar fallback should check the rest);
22428 - pointer to the last unprocessed character (a scalar fallback should check the rest);
23007 // Fallback to scalar code for handling errors
23010 ? scalar::utf16::swap_bytes(buf[k])
23080 A scalar routing should carry on the conversion of the tail.
23279 // Let us do a scalar fallback.
23280 // It may seem wasteful to use scalar code, but being efficient with SIMD
23286 uint16_t word = big_endian ? scalar::utf16::swap_bytes(buf[k]) : buf[k];
23299 uint16_t next_word = big_endian ? scalar::utf16::swap_bytes(buf[k+1]) : buf[k+1];
23321 A scalar routing should carry on the conversion of the tail if needed.
23522 // Let us do a scalar fallback.
23523 // It may seem wasteful to use scalar code, but being efficient with SIMD
23529 uint16_t word = big_endian ? scalar::utf16::swap_bytes(buf[k]) : buf[k];
23542 uint16_t next_word = big_endian ? scalar::utf16::swap_bytes(buf[k+1]) : buf[k+1];
23612 A scalar routing should carry on the conversion of the tail.
23646 // Let us do a scalar fallback.
23647 // It may seem wasteful to use scalar code, but being efficient with SIMD
23653 uint16_t word = big_endian ? scalar::utf16::swap_bytes(buf[k]) : buf[k];
23660 uint16_t next_word = big_endian ? scalar::utf16::swap_bytes(buf[k+1]) : buf[k+1];
23679 A scalar routing should carry on the conversion of the tail if needed.
23714 // Let us do a scalar fallback.
23715 // It may seem wasteful to use scalar code, but being efficient with SIMD
23721 uint16_t word = big_endian ? scalar::utf16::swap_bytes(buf[k]) : buf[k];
23728 uint16_t next_word = big_endian ? scalar::utf16::swap_bytes(buf[k+1]) : buf[k+1];
23806 // Fallback to scalar code for handling errors
24036 // Let us do a scalar fallback.
24037 // It may seem wasteful to use scalar code, but being efficient with SIMD
24286 // Let us do a scalar fallback.
24287 // It may seem wasteful to use scalar code, but being efficient with SIMD
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);
24909 result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
24920 result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
25002 utf16_output += scalar::utf8_to_utf16::convert_valid<endian>(input + pos, size - pos, utf16_output);
25206 size_t howmany = scalar::utf8_to_utf16::convert<endian>(in + pos, size - pos, 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);
25353 utf32_output += scalar::utf8_to_utf32::convert_valid(input + pos, size - pos, utf32_output);
25558 size_t howmany = scalar::utf8_to_utf32::convert(in + pos, size - pos, 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);
25680 return count + scalar::utf8::count_code_points(in + pos, size - pos);
25696 return count + scalar::utf8::utf16_length_from_utf8(in + pos, size - pos);
25719 return count + scalar::utf16::count_code_points<big_endian>(in + pos, size - pos);
25740 return count + scalar::utf16::utf8_length_from_utf16<big_endian>(in + pos, size - pos);
25759 scalar::utf16::change_endianness_utf16(in + pos, size - pos, output);
25958 size_t howmany = scalar::utf8_to_latin1::convert(in + pos, size - pos, 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);
26132 size_t howmany = scalar::utf8_to_latin1::convert_valid(in + pos, size - pos, latin1_output);
26182 return scalar::utf16::validate<endianness::LITTLE>(tail, len - (tail - buf));
26191 return scalar::utf16::validate<endianness::BIG>(tail, len - (tail - buf));
26200 result scalar_res = scalar::utf16::validate_with_errors<endianness::LITTLE>(buf + res.count, len - res.count);
26210 result scalar_res = scalar::utf16::validate_with_errors<endianness::BIG>(buf + res.count, len - res.count);
26220 return scalar::utf32::validate(tail, len - (tail - buf));
26229 result scalar_res = scalar::utf32::validate_with_errors(buf + res.count, len - res.count);
26241 const size_t scalar_converted_chars = scalar::latin1_to_utf8::convert(
26254 const size_t scalar_converted_chars = scalar::latin1_to_utf16::convert<endianness::LITTLE>(
26267 const size_t scalar_converted_chars = scalar::latin1_to_utf16::convert<endianness::BIG>(
26280 const size_t scalar_converted_chars = scalar::latin1_to_utf32::convert(
26354 const size_t scalar_saved_bytes = scalar::utf16_to_latin1::convert<endianness::LITTLE>(
26367 const size_t scalar_saved_bytes = scalar::utf16_to_latin1::convert<endianness::BIG>(
26377 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
26379 result scalar_res = scalar::utf16_to_latin1::convert_with_errors<endianness::LITTLE>(
26394 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
26396 result scalar_res = scalar::utf16_to_latin1::convert_with_errors<endianness::BIG>(
26424 const size_t scalar_saved_bytes = scalar::utf16_to_utf8::convert<endianness::LITTLE>(
26437 const size_t scalar_saved_bytes = scalar::utf16_to_utf8::convert<endianness::BIG>(
26448 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
26450 result scalar_res = scalar::utf16_to_utf8::convert_with_errors<endianness::LITTLE>(
26466 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
26468 result scalar_res = scalar::utf16_to_utf8::convert_with_errors<endianness::BIG>(
26494 const size_t scalar_saved_bytes = scalar::utf32_to_utf8::convert(
26507 const size_t scalar_saved_bytes = scalar::utf32_to_latin1::convert(
26519 result scalar_res = scalar::utf32_to_latin1::convert_with_errors(
26540 result scalar_res = scalar::utf32_to_utf8::convert_with_errors(
26558 const size_t scalar_saved_bytes = scalar::utf16_to_utf32::convert<endianness::LITTLE>(
26571 const size_t scalar_saved_bytes = scalar::utf16_to_utf32::convert<endianness::BIG>(
26582 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
26584 result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::LITTLE>(
26600 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
26602 result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::BIG>(
26624 const size_t scalar_saved_bytes = scalar::utf32_to_utf16::convert<endianness::LITTLE>(
26637 const size_t scalar_saved_bytes = scalar::utf32_to_utf16::convert<endianness::BIG>(
26649 result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::LITTLE>(
26666 result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::BIG>(
26716 return scalar::utf16::latin1_length_from_utf16(length);
26720 return scalar::utf32::latin1_length_from_utf32(length);
26741 return scalar::latin1::utf16_length_from_latin1(length);
26750 return scalar::latin1::utf32_length_from_latin1(length);
26791 return answer + scalar::latin1::utf8_length_from_latin1(reinterpret_cast<const char *>(data + i), len - i);
26817 return count + scalar::utf32::utf8_length_from_utf32(input + pos, length - pos);
26832 return count + scalar::utf32::utf16_length_from_utf32(input + pos, length - pos);
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);
27281 result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
27292 result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
27374 utf16_output += scalar::utf8_to_utf16::convert_valid<endian>(input + pos, size - pos, utf16_output);
27578 size_t howmany = scalar::utf8_to_utf16::convert<endian>(in + pos, size - pos, 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);
27725 utf32_output += scalar::utf8_to_utf32::convert_valid(input + pos, size - pos, utf32_output);
27930 size_t howmany = scalar::utf8_to_utf32::convert(in + pos, size - pos, 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);
28052 return count + scalar::utf8::count_code_points(in + pos, size - pos);
28068 return count + scalar::utf8::utf16_length_from_utf8(in + pos, size - pos);
28091 return count + scalar::utf16::count_code_points<big_endian>(in + pos, size - pos);
28112 return count + scalar::utf16::utf8_length_from_utf16<big_endian>(in + pos, size - pos);
28131 scalar::utf16::change_endianness_utf16(in + pos, size - pos, output);
28179 return scalar::utf16::validate<endianness::LITTLE>(buf, len);
28183 return scalar::utf16::validate<endianness::BIG>(buf, len);
28187 return scalar::utf16::validate_with_errors<endianness::LITTLE>(buf, len);
28191 return scalar::utf16::validate_with_errors<endianness::BIG>(buf, len);
28195 return scalar::utf32::validate_with_errors(buf, len);
28199 return scalar::utf32::validate(buf, len);
28239 return scalar::utf16_to_utf8::convert<endianness::LITTLE>(buf, len, utf8_output);
28243 return scalar::utf16_to_utf8::convert<endianness::BIG>(buf, len, utf8_output);
28247 return scalar::utf16_to_utf8::convert_with_errors<endianness::LITTLE>(buf, len, utf8_output);
28251 return scalar::utf16_to_utf8::convert_with_errors<endianness::BIG>(buf, len, utf8_output);
28255 return scalar::utf16_to_utf8::convert_valid<endianness::LITTLE>(buf, len, utf8_output);
28259 return scalar::utf16_to_utf8::convert_valid<endianness::BIG>(buf, len, utf8_output);
28263 return scalar::utf32_to_utf8::convert(buf, len, utf8_output);
28267 return scalar::utf32_to_utf8::convert_with_errors(buf, len, utf8_output);
28271 return scalar::utf32_to_utf8::convert_valid(buf, len, utf8_output);
28275 return scalar::utf32_to_utf16::convert<endianness::LITTLE>(buf, len, utf16_output);
28279 return scalar::utf32_to_utf16::convert<endianness::BIG>(buf, len, utf16_output);
28283 return scalar::utf32_to_utf16::convert_with_errors<endianness::LITTLE>(buf, len, utf16_output);
28287 return scalar::utf32_to_utf16::convert_with_errors<endianness::BIG>(buf, len, utf16_output);
28291 return scalar::utf32_to_utf16::convert_valid<endianness::LITTLE>(buf, len, utf16_output);
28295 return scalar::utf32_to_utf16::convert_valid<endianness::BIG>(buf, len, utf16_output);
28299 return scalar::utf16_to_utf32::convert<endianness::LITTLE>(buf, len, utf32_output);
28303 return scalar::utf16_to_utf32::convert<endianness::BIG>(buf, len, utf32_output);
28307 return scalar::utf16_to_utf32::convert_with_errors<endianness::LITTLE>(buf, len, utf32_output);
28311 return scalar::utf16_to_utf32::convert_with_errors<endianness::BIG>(buf, len, utf32_output);
28315 return scalar::utf16_to_utf32::convert_valid<endianness::LITTLE>(buf, len, utf32_output);
28319 return scalar::utf16_to_utf32::convert_valid<endianness::BIG>(buf, len, utf32_output);
28323 scalar::utf16::change_endianness_utf16(input, length, output);
28327 return scalar::utf16::count_code_points<endianness::LITTLE>(input, length);
28331 return scalar::utf16::count_code_points<endianness::BIG>(input, length);
28339 return scalar::utf16::utf8_length_from_utf16<endianness::LITTLE>(input, length);
28343 return scalar::utf16::utf8_length_from_utf16<endianness::BIG>(input, length);
28347 return scalar::utf16::utf32_length_from_utf16<endianness::LITTLE>(input, length);
28351 return scalar::utf16::utf32_length_from_utf16<endianness::BIG>(input, length);
28355 return scalar::utf8::utf16_length_from_utf8(input, length);
28359 return scalar::utf32::utf8_length_from_utf32(input, length);
28363 return scalar::utf32::utf16_length_from_utf32(input, length);
28367 return scalar::utf8::count_code_points(input, length);
28687 if (is_utf16 && scalar::utf16::validate<endianness::LITTLE>(reinterpret_cast<const char16_t*>(buf), (len - (buf - start))/2)) {
28694 if (_mm_testz_si128(is_zero, is_zero) == 1 && scalar::utf32::validate(reinterpret_cast<const char32_t*>(buf), (len - (buf - start))/4)) {
28746 - pointer to the last unprocessed character (a scalar fallback should check the rest);
28904 - pointer to the last unprocessed character (a scalar fallback should check the rest);
29523 // Fallback to scalar code for handling errors
29525 uint16_t word = !match_system(big_endian) ? scalar::utf16::swap_bytes(buf[k]) : buf[k];
29590 A scalar routing should carry on the conversion of the tail.
29751 // Let us do a scalar fallback.
29752 // It may seem wasteful to use scalar code, but being efficient with SIMD
29758 uint16_t word = big_endian ? scalar::utf16::swap_bytes(buf[k]) : buf[k];
29771 uint16_t next_word = big_endian ? scalar::utf16::swap_bytes(buf[k+1]) : buf[k+1];
29794 A scalar routing should carry on the conversion of the tail if needed.
29955 // Let us do a scalar fallback.
29956 // It may seem wasteful to use scalar code, but being efficient with SIMD
29962 uint16_t word = big_endian ? scalar::utf16::swap_bytes(buf[k]) : buf[k];
29975 uint16_t next_word = big_endian ? scalar::utf16::swap_bytes(buf[k+1]) : buf[k+1];
30045 A scalar routing should carry on the conversion of the tail.
30080 // Let us do a scalar fallback.
30081 // It may seem wasteful to use scalar code, but being efficient with SIMD
30087 uint16_t word = big_endian ? scalar::utf16::swap_bytes(buf[k]) : buf[k];
30093 uint16_t next_word = big_endian ? scalar::utf16::swap_bytes(buf[k+1]) : buf[k+1];
30112 A scalar routing should carry on the conversion of the tail if needed.
30148 // Let us do a scalar fallback.
30149 // It may seem wasteful to use scalar code, but being efficient with SIMD
30155 uint16_t word = big_endian ? scalar::utf16::swap_bytes(buf[k]) : buf[k];
30161 uint16_t next_word = big_endian ? scalar::utf16::swap_bytes(buf[k+1]) : buf[k+1];
30231 // Fallback to scalar code for handling errors
30474 // Let us do a scalar fallback.
30475 // It may seem wasteful to use scalar code, but being efficient with SIMD
30736 // Let us do a scalar fallback.
30737 // It may seem wasteful to use scalar code, but being efficient with SIMD
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);
31288 result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
31299 result res = scalar::ascii::validate_with_errors(reinterpret_cast<const char*>(input + count), length - count);
31381 utf16_output += scalar::utf8_to_utf16::convert_valid<endian>(input + pos, size - pos, utf16_output);
31585 size_t howmany = scalar::utf8_to_utf16::convert<endian>(in + pos, size - pos, 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);
31732 utf32_output += scalar::utf8_to_utf32::convert_valid(input + pos, size - pos, utf32_output);
31937 size_t howmany = scalar::utf8_to_utf32::convert(in + pos, size - pos, 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);
32059 return count + scalar::utf8::count_code_points(in + pos, size - pos);
32075 return count + scalar::utf8::utf16_length_from_utf8(in + pos, size - pos);
32098 return count + scalar::utf16::count_code_points<big_endian>(in + pos, size - pos);
32119 return count + scalar::utf16::utf8_length_from_utf16<big_endian>(in + pos, size - pos);
32138 scalar::utf16::change_endianness_utf16(in + pos, size - pos, output);
32335 size_t howmany = scalar::utf8_to_latin1::convert(in + pos, size - pos, 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);
32509 size_t howmany = scalar::utf8_to_latin1::convert_valid(in + pos, size - pos, latin1_output);
32564 return scalar::utf16::validate<endianness::LITTLE>(tail, len - (tail - buf));
32573 return scalar::utf16::validate<endianness::BIG>(tail, len - (tail - buf));
32582 result scalar_res = scalar::utf16::validate_with_errors<endianness::LITTLE>(buf + res.count, len - res.count);
32592 result scalar_res = scalar::utf16::validate_with_errors<endianness::BIG>(buf + res.count, len - res.count);
32602 return scalar::utf32::validate(tail, len - (tail - buf));
32611 result scalar_res = scalar::utf32::validate_with_errors(buf + res.count, len - res.count);
32624 const size_t scalar_converted_chars = scalar::latin1_to_utf8::convert(
32637 const size_t scalar_converted_chars = scalar::latin1_to_utf16::convert<endianness::LITTLE>(
32650 const size_t scalar_converted_chars = scalar::latin1_to_utf16::convert<endianness::BIG>(
32663 const size_t scalar_converted_chars = scalar::latin1_to_utf32::convert(
32738 const size_t scalar_saved_bytes = scalar::utf16_to_latin1::convert<endianness::LITTLE>(
32752 const size_t scalar_saved_bytes = scalar::utf16_to_latin1::convert<endianness::BIG>(
32762 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
32764 result scalar_res = scalar::utf16_to_latin1::convert_with_errors<endianness::LITTLE>(
32779 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
32781 result scalar_res = scalar::utf16_to_latin1::convert_with_errors<endianness::BIG>(
32810 const size_t scalar_saved_bytes = scalar::utf16_to_utf8::convert<endianness::LITTLE>(
32823 const size_t scalar_saved_bytes = scalar::utf16_to_utf8::convert<endianness::BIG>(
32834 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
32836 result scalar_res = scalar::utf16_to_utf8::convert_with_errors<endianness::LITTLE>(
32852 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
32854 result scalar_res = scalar::utf16_to_utf8::convert_with_errors<endianness::BIG>(
32881 const size_t scalar_saved_bytes = scalar::utf32_to_latin1::convert(
32894 result scalar_res = scalar::utf32_to_latin1::convert_with_errors(
32917 const size_t scalar_saved_bytes = scalar::utf32_to_utf8::convert(
32929 result scalar_res = scalar::utf32_to_utf8::convert_with_errors(
32947 const size_t scalar_saved_bytes = scalar::utf16_to_utf32::convert<endianness::LITTLE>(
32960 const size_t scalar_saved_bytes = scalar::utf16_to_utf32::convert<endianness::BIG>(
32971 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
32973 result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::LITTLE>(
32989 if (ret.first.error) { return ret.first; } // Can return directly since scalar fallback already found correct ret.first.count
32991 result scalar_res = scalar::utf16_to_utf32::convert_with_errors<endianness::BIG>(
33013 const size_t scalar_saved_bytes = scalar::utf32_to_utf16::convert<endianness::LITTLE>(
33026 const size_t scalar_saved_bytes = scalar::utf32_to_utf16::convert<endianness::BIG>(
33038 result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::LITTLE>(
33055 result scalar_res = scalar::utf32_to_utf16::convert_with_errors<endianness::BIG>(
33105 return scalar::utf16::latin1_length_from_utf16(length);
33109 return scalar::utf32::latin1_length_from_utf32(length);
33121 return scalar::latin1::utf16_length_from_latin1(length);
33125 return scalar::latin1::utf32_length_from_latin1(length);
33172 return answer + scalar::latin1::utf8_length_from_latin1(reinterpret_cast<const char *>(str + i), len - i);
33210 return count + scalar::utf32::utf8_length_from_utf32(input + pos, length - pos);
33225 return count + scalar::utf32::utf16_length_from_utf32(input + pos, length - pos);