xref: /openbmc/u-boot/include/charset.h (revision e35171e9)
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  * console_read_unicode() - read Unicode code point from console
18  *
19  * @code:	pointer to store Unicode code point
20  * Return:	0 = success
21  */
22 int console_read_unicode(s32 *code);
23 
24 /**
25  * utf8_get() - get next UTF-8 code point from buffer
26  *
27  * @src:		pointer to current byte, updated to point to next byte
28  * Return:		code point, or 0 for end of string, or -1 if no legal
29  *			code point is found. In case of an error src points to
30  *			the incorrect byte.
31  */
32 s32 utf8_get(const char **src);
33 
34 /**
35  * utf8_put() - write UTF-8 code point to buffer
36  *
37  * @code:		code point
38  * @dst:		pointer to destination buffer, updated to next position
39  * Return:		-1 if the input parameters are invalid
40  */
41 int utf8_put(s32 code, char **dst);
42 
43 /**
44  * utf8_utf16_strnlen() - length of a truncated utf-8 string after conversion
45  *			  to utf-16
46  *
47  * @src:		utf-8 string
48  * @count:		maximum number of code points to convert
49  * Return:		length in bytes after conversion to utf-16 without the
50  *			trailing \0. If an invalid UTF-8 sequence is hit one
51  *			word will be reserved for a replacement character.
52  */
53 size_t utf8_utf16_strnlen(const char *src, size_t count);
54 
55 /**
56  * utf8_utf16_strlen() - length of a utf-8 string after conversion to utf-16
57  *
58  * @src:		utf-8 string
59  * Return:		length in bytes after conversion to utf-16 without the
60  *			trailing \0. -1 if the utf-8 string is not valid.
61  */
62 #define utf8_utf16_strlen(a) utf8_utf16_strnlen((a), SIZE_MAX)
63 
64 /**
65  * utf8_utf16_strncpy() - copy utf-8 string to utf-16 string
66  *
67  * @dst:		destination buffer
68  * @src:		source buffer
69  * @count:		maximum number of code points to copy
70  * Return:		-1 if the input parameters are invalid
71  */
72 int utf8_utf16_strncpy(u16 **dst, const char *src, size_t count);
73 
74 /**
75  * utf8_utf16_strcpy() - copy utf-8 string to utf-16 string
76  *
77  * @dst:		destination buffer
78  * @src:		source buffer
79  * Return:		-1 if the input parameters are invalid
80  */
81 #define utf8_utf16_strcpy(d, s) utf8_utf16_strncpy((d), (s), SIZE_MAX)
82 
83 /**
84  * utf16_get() - get next UTF-16 code point from buffer
85  *
86  * @src:		pointer to current word, updated to point to next word
87  * Return:		code point, or 0 for end of string, or -1 if no legal
88  *			code point is found. In case of an error src points to
89  *			the incorrect word.
90  */
91 s32 utf16_get(const u16 **src);
92 
93 /**
94  * utf16_put() - write UTF-16 code point to buffer
95  *
96  * @code:		code point
97  * @dst:		pointer to destination buffer, updated to next position
98  * Return:		-1 if the input parameters are invalid
99  */
100 int utf16_put(s32 code, u16 **dst);
101 
102 /**
103  * utf16_strnlen() - length of a truncated utf-16 string
104  *
105  * @src:		utf-16 string
106  * @count:		maximum number of code points to convert
107  * Return:		length in code points. If an invalid UTF-16 sequence is
108  *			hit one position will be reserved for a replacement
109  *			character.
110  */
111 size_t utf16_strnlen(const u16 *src, size_t count);
112 
113 /**
114  * utf16_utf8_strnlen() - length of a truncated utf-16 string after conversion
115  *			  to utf-8
116  *
117  * @src:		utf-16 string
118  * @count:		maximum number of code points to convert
119  * Return:		length in bytes after conversion to utf-8 without the
120  *			trailing \0. If an invalid UTF-16 sequence is hit one
121  *			byte will be reserved for a replacement character.
122  */
123 size_t utf16_utf8_strnlen(const u16 *src, size_t count);
124 
125 /**
126  * utf16_utf8_strlen() - length of a utf-16 string after conversion to utf-8
127  *
128  * @src:		utf-16 string
129  * Return:		length in bytes after conversion to utf-8 without the
130  *			trailing \0. -1 if the utf-16 string is not valid.
131  */
132 #define utf16_utf8_strlen(a) utf16_utf8_strnlen((a), SIZE_MAX)
133 
134 /**
135  * utf16_utf8_strncpy() - copy utf-16 string to utf-8 string
136  *
137  * @dst:		destination buffer
138  * @src:		source buffer
139  * @count:		maximum number of code points to copy
140  * Return:		-1 if the input parameters are invalid
141  */
142 int utf16_utf8_strncpy(char **dst, const u16 *src, size_t count);
143 
144 /**
145  * utf16_utf8_strcpy() - copy utf-16 string to utf-8 string
146  *
147  * @dst:		destination buffer
148  * @src:		source buffer
149  * Return:		-1 if the input parameters are invalid
150  */
151 #define utf16_utf8_strcpy(d, s) utf16_utf8_strncpy((d), (s), SIZE_MAX)
152 
153 /**
154  * utf_to_lower() - convert a Unicode letter to lower case
155  *
156  * @code:		letter to convert
157  * Return:		lower case letter or unchanged letter
158  */
159 s32 utf_to_lower(const s32 code);
160 
161 /**
162  * utf_to_upper() - convert a Unicode letter to upper case
163  *
164  * @code:		letter to convert
165  * Return:		upper case letter or unchanged letter
166  */
167 s32 utf_to_upper(const s32 code);
168 
169 /**
170  * u16_strlen - count non-zero words
171  *
172  * This function matches wsclen() if the -fshort-wchar compiler flag is set.
173  * In the EFI context we explicitly need a function handling u16 strings.
174  *
175  * @in:			null terminated u16 string
176  * ReturnValue:		number of non-zero words.
177  *			This is not the number of utf-16 letters!
178  */
179 size_t u16_strlen(const u16 *in);
180 
181 /**
182  * u16_strlen - count non-zero words
183  *
184  * This function matches wscnlen_s() if the -fshort-wchar compiler flag is set.
185  * In the EFI context we explicitly need a function handling u16 strings.
186  *
187  * @in:			null terminated u16 string
188  * @count:		maximum number of words to count
189  * ReturnValue:		number of non-zero words.
190  *			This is not the number of utf-16 letters!
191  */
192 size_t u16_strnlen(const u16 *in, size_t count);
193 
194 /**
195  * u16_strcpy() - copy u16 string
196  *
197  * Copy u16 string pointed to by src, including terminating null word, to
198  * the buffer pointed to by dest.
199  *
200  * @dest:		destination buffer
201  * @src:		source buffer (null terminated)
202  * Return:		'dest' address
203  */
204 u16 *u16_strcpy(u16 *dest, const u16 *src);
205 
206 /**
207  * u16_strdup() - duplicate u16 string
208  *
209  * Copy u16 string pointed to by src, including terminating null word, to a
210  * newly allocated buffer.
211  *
212  * @src:		source buffer (null terminated)
213  * Return:		allocated new buffer on success, NULL on failure
214  */
215 u16 *u16_strdup(const u16 *src);
216 
217 /**
218  * utf16_to_utf8() - Convert an utf16 string to utf8
219  *
220  * Converts 'size' characters of the utf16 string 'src' to utf8
221  * written to the 'dest' buffer.
222  *
223  * NOTE that a single utf16 character can generate up to 3 utf8
224  * characters.  See MAX_UTF8_PER_UTF16.
225  *
226  * @dest   the destination buffer to write the utf8 characters
227  * @src    the source utf16 string
228  * @size   the number of utf16 characters to convert
229  * @return the pointer to the first unwritten byte in 'dest'
230  */
231 uint8_t *utf16_to_utf8(uint8_t *dest, const uint16_t *src, size_t size);
232 
233 #endif /* __CHARSET_H_ */
234