Lines Matching defs:out
326 // Returns 4-bit out of each byte, alternating between the high 4 bits and low bits
423 // Perform a lookup assuming the value is between 0 and 16 (undefined behavior for out of range values)
1792 // Perform a lookup assuming the value is between 0 and 16 (undefined behavior for out of range values)
1922 // Get one of the bits and make a bitmask out of it.
2189 // Get one of the bits and make a bitmask out of it.
2696 // Perform a lookup assuming the value is between 0 and 16 (undefined behavior for out of range values)
2814 // Get one of the bits and make a bitmask out of it.
3154 // Get one of the bits and make a bitmask out of it.
3630 // for out of range values)
4429 simdutf_really_inline void change_endianness_utf16(const char16_t* in, size_t size, char16_t* out) {
4431 uint16_t * output = reinterpret_cast<uint16_t *>(out);
4881 // from which the user has to figure out whether the string is valid UTF-8... which seems
12684 int out = 0;
12860 out |= simdutf::encoding_type::UTF8;
12865 out |= simdutf::encoding_type::UTF16_LE;
12872 out |= simdutf::encoding_type::UTF32_LE;
12876 return out;
13359 // Mask out lead
15197 std::memset(dst, 0x20, STEP_SIZE); // std::memset STEP_SIZE because it's more efficient to write out 8 or 16 bytes at once.
17450 int out = 0;
17451 if(validate_utf8(input, length)) { out |= encoding_type::UTF8; }
17453 if(validate_utf16le(reinterpret_cast<const char16_t*>(input), length/2)) { out |= encoding_type::UTF16_LE; }
17456 if(validate_utf32(reinterpret_cast<const char32_t*>(input), length/4)) { out |= encoding_type::UTF32_LE; }
17459 return out;
17805 The provided in and out pointers are advanced according to how many input
17809 simdutf_really_inline bool process_block_utf8_to_utf16(const char *&in, char16_t *&out, size_t gap) {
17841 _mm512_storeu_si512(out, input1);
17842 out += 32;
17845 _mm512_storeu_si512(out, input2);
17846 out += 32;
17853 _mm512_mask_storeu_epi16(out, __mmask32((uint64_t(1) << (gap)) - 1), input1);
17854 out += gap;
17858 _mm512_storeu_si512(out, input1);
17859 out += 32;
17862 _mm512_mask_storeu_epi16(out, __mmask32((uint32_t(1) << (gap - 32)) - 1), input2);
17863 out += gap - 32;
17944 // Encodings out of range...
17960 _mm512_mask_storeu_epi16(out, __mmask32((uint64_t(1) << nout) - 1), Wout);
17961 out += nout;
18027 // Encodings out of range...
18045 _mm512_mask_storeu_epi16(out, __mmask32((uint64_t(1) << nout) - 1), Wout);
18046 out += nout;
18091 _mm512_mask_storeu_epi16(out, __mmask32((uint64_t(1) << nout) - 1), final);
18092 out += nout; // UTF-8 to UTF-16 is only expansionary in this case.
18095 _mm512_mask_storeu_epi16(out, __mmask32((uint64_t(1) << nout) - 1), final);
18096 out += nout; // UTF-8 to UTF-16 is only expansionary in this case.
18528 const __m512i out = _mm512_mask_compress_epi32(_mm512_setzero_si512(), leading_bytes, utf32); \
18533 _mm512_mask_storeu_epi32((__m512i*)output, valid, out); \
18535 _mm512_storeu_si512((__m512i*)output, out); \
18540 output += utf32_to_utf16_masked<big_endian>(byteflip, out, valid_count, reinterpret_cast<char16_t *>(output)); \
18542 output += utf32_to_utf16<big_endian>(byteflip, out, valid_count, reinterpret_cast<char16_t *>(output)); \
18863 * out.
18869 utf8_to_utf16_result fast_avx512_convert_utf8_to_utf16(const char *in, size_t len, char16_t *out) {
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; }
18880 return std::make_pair(in, out);
18884 simdutf::result fast_avx512_convert_utf8_to_utf16_with_errors(const char *in, size_t len, char16_t *out) {
18886 const char16_t *const init_out = out;
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);
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);
19211 // This commented out line is 5% faster but sadly it'll also write past
19499 const __m512i out = _mm512_maskz_compress_epi8(smoosh, in);
19501 out);
20605 __m512i out = _mm512_cvtepu8_epi16(in);
20607 out = _mm512_shuffle_epi8(out, byteflip);
20610 _mm512_storeu_si512((__m512i *)&utf16_output[i], out);
20617 __m512i out = _mm512_cvtepu8_epi16(in);
20619 out = _mm512_shuffle_epi8(out, byteflip);
20622 _mm512_mask_storeu_epi16(utf16_output + rounded_len, mask, out);
20637 __m512i out = _mm512_cvtepu8_epi32(in);
20640 _mm512_storeu_si512((__m512i*)&utf32_output[i], out);
20674 int out = 0;
20758 out |= simdutf::encoding_type::UTF8;
20765 out |= simdutf::encoding_type::UTF16_LE;
20777 out |= simdutf::encoding_type::UTF32_LE;
20781 return out;
22048 int out = 0;
22206 out |= simdutf::encoding_type::UTF8;
22211 out |= simdutf::encoding_type::UTF16_LE;
22218 out |= simdutf::encoding_type::UTF32_LE;
22222 return out;
22618 __m256i out = _mm256_cvtepu8_epi32(in);
22621 _mm256_storeu_si256((__m256i*)&utf32_output[i], out);
24608 std::memset(dst, 0x20, STEP_SIZE); // std::memset STEP_SIZE because it's more efficient to write out 8 or 16 bytes at once.
26980 std::memset(dst, 0x20, STEP_SIZE); // std::memset STEP_SIZE because it's more efficient to write out 8 or 16 bytes at once.
28150 int out = 0;
28151 if(validate_utf8(input, length)) { out |= encoding_type::UTF8; }
28153 if(validate_utf16(reinterpret_cast<const char16_t*>(input), length/2)) { out |= encoding_type::UTF16_LE; }
28156 if(validate_utf32(reinterpret_cast<const char32_t*>(input), length/4)) { out |= encoding_type::UTF32_LE; }
28159 return out;
28505 int out = 0;
28683 out |= simdutf::encoding_type::UTF8;
28688 out |= simdutf::encoding_type::UTF16_LE;
28695 out |= simdutf::encoding_type::UTF32_LE;
28699 return out;
30326 // no bits set above 7th bit -- find out all the ASCII characters
30987 std::memset(dst, 0x20, STEP_SIZE); // std::memset STEP_SIZE because it's more efficient to write out 8 or 16 bytes at once.