1/* SPDX-License-Identifier: GPL-2.0+ */ 2/* 3 * charset conversion utils 4 * 5 * Copyright (c) 2017 Rob Clark 6 */ 7 8#ifndef __CHARSET_H_ 9#define __CHARSET_H_ 10 11#include <linux/kernel.h> 12#include <linux/types.h> 13 14#define MAX_UTF8_PER_UTF16 3 15 16/* 17 * codepage_437 - Unicode to codepage 437 translation table 18 */ 19extern const u16 codepage_437[128]; 20 21/** 22 * console_read_unicode() - read Unicode code point from console 23 * 24 * @code: pointer to store Unicode code point 25 * Return: 0 = success 26 */ 27int console_read_unicode(s32 *code); 28 29/** 30 * utf8_get() - get next UTF-8 code point from buffer 31 * 32 * @src: pointer to current byte, updated to point to next byte 33 * Return: code point, or 0 for end of string, or -1 if no legal 34 * code point is found. In case of an error src points to 35 * the incorrect byte. 36 */ 37s32 utf8_get(const char **src); 38 39/** 40 * utf8_put() - write UTF-8 code point to buffer 41 * 42 * @code: code point 43 * @dst: pointer to destination buffer, updated to next position 44 * Return: -1 if the input parameters are invalid 45 */ 46int utf8_put(s32 code, char **dst); 47 48/** 49 * utf8_utf16_strnlen() - length of a truncated utf-8 string after conversion 50 * to utf-16 51 * 52 * @src: utf-8 string 53 * @count: maximum number of code points to convert 54 * Return: length in u16 after conversion to utf-16 without the 55 * trailing \0. If an invalid UTF-8 sequence is hit one 56 * u16 will be reserved for a replacement character. 57 */ 58size_t utf8_utf16_strnlen(const char *src, size_t count); 59 60/** 61 * utf8_utf16_strlen() - length of a utf-8 string after conversion to utf-16 62 * 63 * @a: utf-8 string 64 * Return: length in u16 after conversion to utf-16 without the 65 * trailing \0. If an invalid UTF-8 sequence is hit one 66 * u16 will be reserved for a replacement character. 67 */ 68#define utf8_utf16_strlen(a) utf8_utf16_strnlen((a), SIZE_MAX) 69 70/** 71 * utf8_utf16_strncpy() - copy utf-8 string to utf-16 string 72 * 73 * @dst: destination buffer 74 * @src: source buffer 75 * @count: maximum number of code points to copy 76 * Return: -1 if the input parameters are invalid 77 */ 78int utf8_utf16_strncpy(u16 **dst, const char *src, size_t count); 79 80/** 81 * utf8_utf16_strcpy() - copy utf-8 string to utf-16 string 82 * 83 * @d: destination buffer 84 * @s: source buffer 85 * Return: -1 if the input parameters are invalid 86 */ 87#define utf8_utf16_strcpy(d, s) utf8_utf16_strncpy((d), (s), SIZE_MAX) 88 89/** 90 * utf16_get() - get next UTF-16 code point from buffer 91 * 92 * @src: pointer to current word, updated to point to next word 93 * Return: code point, or 0 for end of string, or -1 if no legal 94 * code point is found. In case of an error src points to 95 * the incorrect word. 96 */ 97s32 utf16_get(const u16 **src); 98 99/** 100 * utf16_put() - write UTF-16 code point to buffer 101 * 102 * @code: code point 103 * @dst: pointer to destination buffer, updated to next position 104 * Return: -1 if the input parameters are invalid 105 */ 106int utf16_put(s32 code, u16 **dst); 107 108/** 109 * utf16_strnlen() - length of a truncated utf-16 string 110 * 111 * @src: utf-16 string 112 * @count: maximum number of code points to convert 113 * Return: length in code points. If an invalid UTF-16 sequence is 114 * hit one position will be reserved for a replacement 115 * character. 116 */ 117size_t utf16_strnlen(const u16 *src, size_t count); 118 119/** 120 * utf16_utf8_strnlen() - length of a truncated utf-16 string after conversion 121 * to utf-8 122 * 123 * @src: utf-16 string 124 * @count: maximum number of code points to convert 125 * Return: length in bytes after conversion to utf-8 without the 126 * trailing \0. If an invalid UTF-16 sequence is hit one 127 * byte will be reserved for a replacement character. 128 */ 129size_t utf16_utf8_strnlen(const u16 *src, size_t count); 130 131/** 132 * utf16_utf8_strlen() - length of a utf-16 string after conversion to utf-8 133 * 134 * @a: utf-16 string 135 * Return: length in bytes after conversion to utf-8 without the 136 * trailing \0. If an invalid UTF-16 sequence is hit one 137 * byte will be reserved for a replacement character. 138 */ 139#define utf16_utf8_strlen(a) utf16_utf8_strnlen((a), SIZE_MAX) 140 141/** 142 * utf16_utf8_strncpy() - copy utf-16 string to utf-8 string 143 * 144 * @dst: destination buffer 145 * @src: source buffer 146 * @count: maximum number of code points to copy 147 * Return: -1 if the input parameters are invalid 148 */ 149int utf16_utf8_strncpy(char **dst, const u16 *src, size_t count); 150 151/** 152 * utf16_utf8_strcpy() - copy utf-16 string to utf-8 string 153 * 154 * @d: destination buffer 155 * @s: source buffer 156 * Return: -1 if the input parameters are invalid 157 */ 158#define utf16_utf8_strcpy(d, s) utf16_utf8_strncpy((d), (s), SIZE_MAX) 159 160/** 161 * utf_to_lower() - convert a Unicode letter to lower case 162 * 163 * @code: letter to convert 164 * Return: lower case letter or unchanged letter 165 */ 166s32 utf_to_lower(const s32 code); 167 168/** 169 * utf_to_upper() - convert a Unicode letter to upper case 170 * 171 * @code: letter to convert 172 * Return: upper case letter or unchanged letter 173 */ 174s32 utf_to_upper(const s32 code); 175 176/** 177 * u16_strncmp() - compare two u16 string 178 * 179 * @s1: first string to compare 180 * @s2: second string to compare 181 * @n: maximum number of u16 to compare 182 * Return: 0 if the first n u16 are the same in s1 and s2 183 * < 0 if the first different u16 in s1 is less than the 184 * corresponding u16 in s2 185 * > 0 if the first different u16 in s1 is greater than the 186 * corresponding u16 in s2 187 */ 188int u16_strncmp(const u16 *s1, const u16 *s2, size_t n); 189 190/** 191 * u16_strcmp() - compare two u16 string 192 * 193 * @s1: first string to compare 194 * @s2: second string to compare 195 * Return: 0 if the first n u16 are the same in s1 and s2 196 * < 0 if the first different u16 in s1 is less than the 197 * corresponding u16 in s2 198 * > 0 if the first different u16 in s1 is greater than the 199 * corresponding u16 in s2 200 */ 201#define u16_strcmp(s1, s2) u16_strncmp((s1), (s2), SIZE_MAX) 202 203/** 204 * u16_strlen - count non-zero words 205 * 206 * This function matches wsclen() if the -fshort-wchar compiler flag is set. 207 * In the EFI context we explicitly need a function handling u16 strings. 208 * 209 * @in: null terminated u16 string 210 * Return: number of non-zero words. 211 * This is not the number of utf-16 letters! 212 */ 213size_t u16_strlen(const void *in); 214 215/** 216 * u16_strsize() - count size of u16 string in bytes including the null 217 * character 218 * 219 * Counts the number of bytes occupied by a u16 string 220 * 221 * @in: null terminated u16 string 222 * Return: bytes in a u16 string 223 */ 224size_t u16_strsize(const void *in); 225 226/** 227 * u16_strnlen() - count non-zero words 228 * 229 * This function matches wscnlen_s() if the -fshort-wchar compiler flag is set. 230 * In the EFI context we explicitly need a function handling u16 strings. 231 * 232 * @in: null terminated u16 string 233 * @count: maximum number of words to count 234 * Return: number of non-zero words. 235 * This is not the number of utf-16 letters! 236 */ 237size_t u16_strnlen(const u16 *in, size_t count); 238 239/** 240 * u16_strcpy() - copy u16 string 241 * 242 * Copy u16 string pointed to by src, including terminating null word, to 243 * the buffer pointed to by dest. 244 * 245 * @dest: destination buffer 246 * @src: source buffer (null terminated) 247 * Return: 'dest' address 248 */ 249u16 *u16_strcpy(u16 *dest, const u16 *src); 250 251/** 252 * u16_strdup() - duplicate u16 string 253 * 254 * Copy u16 string pointed to by src, including terminating null word, to a 255 * newly allocated buffer. 256 * 257 * @src: source buffer (null terminated) 258 * Return: allocated new buffer on success, NULL on failure 259 */ 260u16 *u16_strdup(const void *src); 261 262/** 263 * utf16_to_utf8() - Convert an utf16 string to utf8 264 * 265 * Converts 'size' characters of the utf16 string 'src' to utf8 266 * written to the 'dest' buffer. 267 * 268 * NOTE that a single utf16 character can generate up to 3 utf8 269 * characters. See MAX_UTF8_PER_UTF16. 270 * 271 * @dest: the destination buffer to write the utf8 characters 272 * @src: the source utf16 string 273 * @size: the number of utf16 characters to convert 274 * Return: the pointer to the first unwritten byte in 'dest' 275 */ 276uint8_t *utf16_to_utf8(uint8_t *dest, const uint16_t *src, size_t size); 277 278/** 279 * utf_to_cp() - translate Unicode code point to 8bit codepage 280 * 281 * Codepoints that do not exist in the codepage are rendered as question mark. 282 * 283 * @c: pointer to Unicode code point to be translated 284 * @codepage: Unicode to codepage translation table 285 * Return: 0 on success, -ENOENT if codepoint cannot be translated 286 */ 287int utf_to_cp(s32 *c, const u16 *codepage); 288 289/** 290 * utf8_to_cp437_stream() - convert UTF-8 stream to codepage 437 291 * 292 * @c: next UTF-8 character to convert 293 * @buffer: buffer, at least 5 characters 294 * Return: next codepage 437 character or 0 295 */ 296int utf8_to_cp437_stream(u8 c, char *buffer); 297 298/** 299 * utf8_to_utf32_stream() - convert UTF-8 stream to UTF-32 300 * 301 * @c: next UTF-8 character to convert 302 * @buffer: buffer, at least 5 characters 303 * Return: next codepage 437 character or 0 304 */ 305int utf8_to_utf32_stream(u8 c, char *buffer); 306 307#endif /* __CHARSET_H_ */ 308