Lines Matching refs:one
685 // Add each of the elements next to each other, successively, to stuff each 8 byte mask into one.
990 // Add each of the elements next to each other, successively, to stuff each 8 byte mask into one.
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.
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.
10783 // will generate one UTF-8 bytes
10847 // will generate one UTF-8 bytes
10896 // will generate one UTF-8 bytes
11086 // will generate one UTF-8 bytes
11159 // will generate one UTF-8 bytes
11218 // will generate one UTF-8 bytes
11405 // converting one ASCII byte !!!
11493 // converting one ASCII byte !!!
11582 // converting one ASCII byte !!!
11737 // converting one ASCII byte !!!
11805 // converting one ASCII byte !!!
11877 // converting one ASCII byte !!!
12018 // will generate one UTF-8 bytes
12147 // converting one ASCII byte !!!
12195 // converting one ASCII byte !!!
12454 // converting one ASCII byte !!!
12588 // guaranteed to be at least *one* lead byte that is part of only 1 other multibyte character.
12721 // On the other hand, to be valid UTF-16LE, at least one surrogate must be in the two most significant
12890 // byte of each word, we compress the two vectors into one which
12924 const uint64_t a = L & (H >> 4); // A low surrogate must be followed by high one.
12929 const uint64_t c = V | a | b; // Combine all the masks into the final one.
12938 // one, 2) reject sole high surrogate.
12960 // byte of each word, we compress the two vectors into one which
12995 const uint64_t a = L & (H >> 4); // A low surrogate must be followed by high one.
13000 const uint64_t c = V | a | b; // Combine all the masks into the final one.
13009 // one, 2) reject sole high surrogate.
13414 // in one magic 16-bit addition.
13789 a single word may produce one, two or three UTF8 bytes.
13793 cases), while the second one contains just the third byte for
13925 differ by exactly one bit.
14179 differ by exactly one bit.
14341 a single word may produce one, two or three UTF8 bytes.
14345 cases), while the second one contains just the third byte for
14633 differ by exactly one bit.
14725 // At least one 32-bit word will produce a surrogate pair in UTF-16 <=> will produce four UTF-8 bytes.
14871 differ by exactly one bit.
14964 // At least one 32-bit word will produce a surrogate pair in UTF-16 <=> will produce four UTF-8 bytes.
16279 // We count one word for anything that is not a continuation (so
19167 __m512i one,
19186 _mm512_mask_cmpgt_epu8_mask(leading, highbits, one);
19199 __mmask64 bit6 = _mm512_cmpeq_epi8_mask(highbits, one);
19228 __m512i one = _mm512_set1_epi8(1);
19234 one, &next_leading, &next_bit6);
19245 process_block_from_utf8_to_latin1<true>(buf + pos, remaining, latin_output, minus64, one,
19264 __m512i minus64, __m512i one,
19285 __mmask64 bit6 = _mm512_cmpeq_epi8_mask(highbits, one);
19304 __m512i one = _mm512_set1_epi8(1);
19310 buf + pos, 64, latin_output, minus64, one, &next_leading, &next_bit6);
19319 one, &next_leading, &next_bit6);
19666 const __mmask32 V = (L ^ (carry | (H << 1))); // A high surrogate must be followed by low one and a low one must be preceded by a high one.
19682 /* 2. Shift by one 16-bit word to align low surrogates with high surrogates
19931 differ by exactly one bit.
20016 // case: at least one 32-bit word is larger than 0xFFFF <=> it will produce four UTF-8 bytes.
20181 differ by exactly one bit.
20266 // case: at least one 32-bit word is larger than 0xFFFF <=> it will produce four UTF-8 bytes.
20689 // be valid UTF-16LE, at least one surrogate must be in the two most
21916 // We count one word for anything that is not a continuation (so
22078 // On the other hand, to be valid UTF-16LE, at least one surrogate must be in the two most significant
22283 // byte of each word, we compress the two vectors into one which
22322 const uint32_t a = L & (H >> 1); // A low surrogate must be followed by high one.
22327 const uint32_t c = V | a | b; // Combine all the masks into the final one.
22337 // one, 2) reject sole high surrogate.
22361 // byte of each word, we compress the two vectors into one which
22400 const uint32_t a = L & (H >> 1); // A low surrogate must be followed by high one.
22405 const uint32_t c = V | a | b; // Combine all the masks into the final one.
22415 // one, 2) reject sole high surrogate.
23057 a single word may produce one, two or three UTF8 bytes.
23061 cases), while the second one contains just the third byte for
23193 differ by exactly one bit.
23436 differ by exactly one bit.
23589 a single word may produce one, two or three UTF8 bytes.
23593 cases), while the second one contains just the third byte for
23950 differ by exactly one bit.
24035 // case: at least one 32-bit word is larger than 0xFFFF <=> it will produce four UTF-8 bytes.
24200 differ by exactly one bit.
24285 // case: at least one 32-bit word is larger than 0xFFFF <=> it will produce four UTF-8 bytes.
25690 // We count one word for anything that is not a continuation (so
28062 // We count one word for anything that is not a continuation (so
28544 // On the other hand, to be valid UTF-16LE, at least one surrogate must be in the two most significant
28760 // byte of each word, we compress the two vectors into one which
28798 const uint16_t a = static_cast<uint16_t>(L & (H >> 1)); // A low surrogate must be followed by high one.
28803 const uint16_t c = static_cast<uint16_t>(V | a | b); // Combine all the masks into the final one.
28813 // one, 2) reject sole high surrogate.
28837 // byte of each word, we compress the two vectors into one which
28876 const uint16_t a = static_cast<uint16_t>(L & (H >> 1)); // A low surrogate must be followed by high one.
28881 const uint16_t c = static_cast<uint16_t>(V | a | b); // Combine all the masks into the final one.
28891 // one, 2) reject sole high surrogate.
29568 a single word may produce one, two or three UTF8 bytes.
29572 cases), while the second one contains just the third byte for
29682 differ by exactly one bit.
29886 differ by exactly one bit.
30023 a single word may produce one, two or three UTF8 bytes.
30027 cases), while the second one contains just the third byte for
30339 // case: all code units either produce 1 or 2 UTF-8 bytes (at least one produces 2 bytes)
30405 differ by exactly one bit.
30473 // case: at least one 32-bit word produce a surrogate pair in UTF-16 <=> will produce four UTF-8 bytes
30595 // case: all code units either produce 1 or 2 UTF-8 bytes (at least one produces 2 bytes)
30667 differ by exactly one bit.
30735 // case: at least one 32-bit word produce a surrogate pair in UTF-16 <=> will produce four UTF-8 bytes
32069 // We count one word for anything that is not a continuation (so