32 if (current_character >= 0x110000) {
36 const uint16_t*
const decomposition =
38 size_t decomposition_length =
39 (decomposition[1] >> 2) - (decomposition[0] >> 2);
40 if ((decomposition_length > 0) && (decomposition[0] & 1)) {
41 decomposition_length = 0;
43 return decomposition_length;
47 const std::u32string_view input)
noexcept {
48 bool decomposition_needed{
false};
49 size_t additional_elements{0};
50 for (
char32_t current_character : input) {
51 size_t decomposition_length{0};
56 decomposition_length = 2;
58 decomposition_length = 3;
60 }
else if (current_character < 0x110000) {
62 const uint16_t*
const decomposition =
64 decomposition_length = (decomposition[1] >> 2) - (decomposition[0] >> 2);
65 if ((decomposition_length > 0) && (decomposition[0] & 1)) {
66 decomposition_length = 0;
69 if (decomposition_length != 0) {
70 decomposition_needed =
true;
71 additional_elements += decomposition_length - 1;
74 return {decomposition_needed, additional_elements};
77void decompose(std::u32string& input,
size_t additional_elements) {
78 input.resize(input.size() + additional_elements);
79 for (
size_t descending_idx = input.size(),
80 input_count = descending_idx - additional_elements;
89 input[--descending_idx] =
92 }
else if (input[input_count] < 0x110000) {
93 const uint16_t* decomposition =
96 (input[input_count] % 256);
97 uint16_t decomposition_length =
98 (decomposition[1] >> 2) - (decomposition[0] >> 2);
99 if (decomposition_length > 0 && (decomposition[0] & 1)) {
100 decomposition_length = 0;
102 if (decomposition_length > 0) {
103 const size_t base =
static_cast<size_t>(decomposition[0] >> 2);
105 input[--descending_idx] = input[input_count];
107 while (decomposition_length-- > 0) {
108 input[--descending_idx] =
113 input[--descending_idx] = input[input_count];
116 input[--descending_idx] = input[input_count];
121uint8_t
get_ccc(
char32_t c)
noexcept {
129 for (
size_t idx = 1; idx < input.size(); idx++) {
130 uint8_t ccc =
get_ccc(input[idx]);
134 auto current_character = input[idx];
135 size_t back_idx = idx;
136 while (back_idx != 0 &&
get_ccc(input[back_idx - 1]) > ccc) {
137 input[back_idx] = input[back_idx - 1];
140 input[back_idx] = current_character;
149 auto [decomposition_needed, additional_elements] =
151 if (decomposition_needed) {
159 char32_t second)
noexcept {
160 int left = composition[0];
161 int right = composition[1];
162 if (left < 0 || right <= left ||
166 while (left + 2 < right) {
167 int middle = left + (((right - left) >> 1) & ~1);
181 for (
size_t input_count = 0; input_count < input.size();) {
182 const char32_t current = input[input_count];
184 if (input_count + 1 < input.size() &&
194 input_count + 1 < input.size() &&
202 if (current < 0x110000) {
203 const uint16_t* composition =
206 int32_t previous_ccc = -1;
207 size_t j = input_count;
208 for (; j + 1 < input.size(); ++j) {
209 uint8_t ccc =
get_ccc(input[j + 1]);
210 if (composition[1] != composition[0] && previous_ccc < ccc &&
237 const uint16_t*
const decomposition =
239 const size_t base = decomposition[0] >> 2;
243void compose(std::u32string& input);
262 const uint16_t*
const decomposition =
264 const size_t length = (decomposition[1] >> 2) - (decomposition[0] >> 2);
265 if (length == 0 || (decomposition[0] & 1)) {
271 const size_t base = decomposition[0] >> 2;
280 if (!(decomposed.size() == 1 && decomposed[0] == c)) {
283 return previous < 0x110000 &&
302 char32_t previous = 0x110000;
303 for (
char32_t c : input) {
312 uint8_t prev_ccc = 0;
313 for (
char32_t c : input) {
315 if (ccc != 0 && prev_ccc > ccc) {
324void compose(std::u32string& input) {
329 size_t input_count{0};
330 size_t composition_count{0};
331 for (; input_count < input.size(); input_count++, composition_count++) {
332 input[composition_count] = input[input_count];
335 if (input_count + 1 < input.size() &&
338 input[composition_count] =
344 if (input_count + 1 < input.size() &&
347 input[composition_count] += input[++input_count] -
hangul_tbase;
353 input_count + 1 < input.size() &&
356 input[composition_count] += input[++input_count] -
hangul_tbase;
358 }
else if (input[input_count] < 0x110000) {
359 const uint16_t* composition =
361 (input[input_count] % 256);
362 size_t initial_composition_count = composition_count;
363 for (int32_t previous_ccc = -1; input_count + 1 < input.size();
365 uint8_t ccc =
get_ccc(input[input_count + 1]);
367 if (composition[1] != composition[0] && previous_ccc < ccc) {
368 int left = composition[0];
369 int right = composition[1];
370 if (left < 0 || right < left ||
374 while (left + 2 < right) {
375 int middle = left + (((right - left) >> 1) & ~1);
377 input[input_count + 1]) {
381 input[input_count + 1]) {
387 input[input_count + 1]) {
389 input[initial_composition_count] = composed;
401 input[++composition_count] = input[input_count + 1];
406 if (composition_count < input_count) {
407 input.resize(composition_count);
bool tables_are_ready() noexcept
void compose(std::u32string &input)
constexpr char32_t hangul_tcount
void decompose(std::u32string &input, size_t additional_elements)
const uint8_t * ccc_block_row(uint8_t bi) noexcept
const uint8_t * ccc_index
void decompose_nfc(std::u32string &input)
const char32_t * decomposition_data
const uint8_t * decomposition_index
constexpr char32_t hangul_ncount
static bool decomposition_is_not_nfc(char32_t previous, char32_t c) noexcept
constexpr char32_t hangul_lbase
static bool has_composition(const uint16_t *composition, char32_t second) noexcept
void sort_marks(std::u32string &input)
constexpr char32_t hangul_lcount
constexpr char32_t hangul_scount
constexpr char32_t hangul_sbase
constexpr char32_t hangul_vbase
bool normalize(std::u32string &input)
uint8_t get_ccc(char32_t c) noexcept
const char32_t * composition_data
bool ensure_tables() noexcept
const uint8_t * composition_index
static bool would_compose(std::u32string_view input) noexcept
constexpr size_t decomposition_data_size
const uint16_t * decomposition_block_row(uint8_t bi) noexcept
static uint8_t trailing_ccc(char32_t c) noexcept
bool is_already_nfc(std::u32string_view input) noexcept
std::pair< bool, size_t > compute_decomposition_length(const std::u32string_view input) noexcept
constexpr char32_t hangul_vcount
constexpr char32_t hangul_tbase
const uint16_t * composition_block_row(uint8_t bi) noexcept
static size_t canonical_decomp_length(char32_t current_character) noexcept
constexpr size_t composition_data_size