1 // SPDX-License-Identifier: GPL-2.0+
3 * charset conversion utils
5 * Copyright (c) 2017 Rob Clark
10 #include <capitalization.h>
13 static struct capitalization_table capitalization_table[] =
14 #ifdef CONFIG_EFI_UNICODE_CAPITALIZATION
15 UNICODE_CAPITALIZATION_TABLE;
16 #elif CONFIG_FAT_DEFAULT_CODEPAGE == 1250
17 CP1250_CAPITALIZATION_TABLE;
19 CP437_CAPITALIZATION_TABLE;
23 * get_code() - read Unicode code point from UTF-8 stream
25 * @read_u8: - stream reader
26 * @src: - string buffer passed to stream reader, optional
27 * Return: - Unicode code point
29 static int get_code(u8 (*read_u8)(void *data), void *data)
36 if (ch >= 0xc2 && ch <= 0xf4) {
45 if (ch < 0x80 || ch > 0xbf)
53 if ((code >= 0xD800 && code <= 0xDFFF) ||
57 if (ch < 0x80 || ch > 0xbf)
60 /* 0xc0 - 0xdf or continuation byte (0x80 - 0xbf) */
64 if (ch < 0x80 || ch > 0xbf)
68 } else if (ch >= 0x80) {
77 * read_string() - read byte from character string
79 * @data: - pointer to string
82 * The string pointer is incremented if it does not point to '\0'.
84 static u8 read_string(void *data)
87 const char **src = (const char **)data;
90 if (!src || !*src || !**src)
98 * read_console() - read byte from console
100 * @src - not used, needed to match interface
101 * Return: - byte read
103 static u8 read_console(void *data)
108 int console_read_unicode(s32 *code)
111 /* No input available */
115 /* Read Unicode code */
116 *code = get_code(read_console, NULL);
120 s32 utf8_get(const char **src)
122 return get_code(read_string, src);
125 int utf8_put(s32 code, char **dst)
129 if ((code >= 0xD800 && code <= 0xDFFF) || code >= 0x110000)
131 if (code <= 0x007F) {
134 if (code <= 0x07FF) {
135 **dst = code >> 6 | 0xC0;
137 if (code < 0x10000) {
138 **dst = code >> 12 | 0xE0;
140 **dst = code >> 18 | 0xF0;
142 **dst = (code >> 12 & 0x3F) | 0x80;
145 **dst = (code >> 6 & 0x3F) | 0x80;
148 **dst = (code & 0x3F) | 0x80;
154 size_t utf8_utf16_strnlen(const char *src, size_t count)
158 for (; *src && count; --count) {
159 s32 code = utf8_get(&src);
164 /* Reserve space for a replacement character */
166 } else if (code < 0x10000) {
175 int utf8_utf16_strncpy(u16 **dst, const char *src, size_t count)
177 if (!src || !dst || !*dst)
180 for (; count && *src; --count) {
181 s32 code = utf8_get(&src);
185 utf16_put(code, dst);
191 s32 utf16_get(const u16 **src)
201 if (code >= 0xDC00 && code <= 0xDFFF)
203 if (code >= 0xD800 && code <= 0xDBFF) {
211 if (code2 <= 0xDC00 || code2 >= 0xDFFF)
219 int utf16_put(s32 code, u16 **dst)
223 if ((code >= 0xD800 && code <= 0xDFFF) || code >= 0x110000)
225 if (code < 0x10000) {
229 **dst = code >> 10 | 0xD800;
231 **dst = (code & 0x3ff) | 0xDC00;
237 size_t utf16_strnlen(const u16 *src, size_t count)
241 for (; *src && count; --count) {
242 s32 code = utf16_get(&src);
247 * In case of an illegal sequence still reserve space for a
248 * replacement character.
255 size_t utf16_utf8_strnlen(const u16 *src, size_t count)
259 for (; *src && count; --count) {
260 s32 code = utf16_get(&src);
265 /* Reserve space for a replacement character */
267 else if (code < 0x80)
269 else if (code < 0x800)
271 else if (code < 0x10000)
279 int utf16_utf8_strncpy(char **dst, const u16 *src, size_t count)
281 if (!src || !dst || !*dst)
284 for (; count && *src; --count) {
285 s32 code = utf16_get(&src);
295 s32 utf_to_lower(const s32 code)
297 struct capitalization_table *pos = capitalization_table;
301 if (code >= 'A' && code <= 'Z')
305 for (; pos->upper; ++pos) {
306 if (pos->upper == code) {
314 s32 utf_to_upper(const s32 code)
316 struct capitalization_table *pos = capitalization_table;
320 if (code >= 'a' && code <= 'z')
324 for (; pos->lower; ++pos) {
325 if (pos->lower == code) {
333 size_t u16_strlen(const u16 *in)
336 for (i = 0; in[i]; i++);
340 size_t u16_strnlen(const u16 *in, size_t count)
343 for (i = 0; count-- && in[i]; i++);
347 /* Convert UTF-16 to UTF-8. */
348 uint8_t *utf16_to_utf8(uint8_t *dest, const uint16_t *src, size_t size)
350 uint32_t code_high = 0;
353 uint32_t code = *src++;
356 if (code >= 0xDC00 && code <= 0xDFFF) {
357 /* Surrogate pair. */
358 code = ((code_high - 0xD800) << 10) + (code - 0xDC00) + 0x10000;
360 *dest++ = (code >> 18) | 0xF0;
361 *dest++ = ((code >> 12) & 0x3F) | 0x80;
362 *dest++ = ((code >> 6) & 0x3F) | 0x80;
363 *dest++ = (code & 0x3F) | 0x80;
367 /* *src may be valid. Don't eat it. */
373 if (code <= 0x007F) {
375 } else if (code <= 0x07FF) {
376 *dest++ = (code >> 6) | 0xC0;
377 *dest++ = (code & 0x3F) | 0x80;
378 } else if (code >= 0xD800 && code <= 0xDBFF) {
381 } else if (code >= 0xDC00 && code <= 0xDFFF) {
384 } else if (code < 0x10000) {
385 *dest++ = (code >> 12) | 0xE0;
386 *dest++ = ((code >> 6) & 0x3F) | 0x80;
387 *dest++ = (code & 0x3F) | 0x80;
389 *dest++ = (code >> 18) | 0xF0;
390 *dest++ = ((code >> 12) & 0x3F) | 0x80;
391 *dest++ = ((code >> 6) & 0x3F) | 0x80;
392 *dest++ = (code & 0x3F) | 0x80;