Merge tag 'efi-2019-10-rc4-5' of https://gitlab.denx.de/u-boot/custodians/u-boot-efi
[platform/kernel/u-boot.git] / include / charset.h
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 u16 after conversion to utf-16 without the
50  *                      trailing \0. If an invalid UTF-8 sequence is hit one
51  *                      u16 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 u16 after conversion to utf-16 without the
60  *                      trailing \0. If an invalid UTF-8 sequence is hit one
61  *                      u16 will be reserved for a replacement character.
62  */
63 #define utf8_utf16_strlen(a) utf8_utf16_strnlen((a), SIZE_MAX)
64
65 /**
66  * utf8_utf16_strncpy() - copy utf-8 string to utf-16 string
67  *
68  * @dst:                destination buffer
69  * @src:                source buffer
70  * @count:              maximum number of code points to copy
71  * Return:              -1 if the input parameters are invalid
72  */
73 int utf8_utf16_strncpy(u16 **dst, const char *src, size_t count);
74
75 /**
76  * utf8_utf16_strcpy() - copy utf-8 string to utf-16 string
77  *
78  * @dst:                destination buffer
79  * @src:                source buffer
80  * Return:              -1 if the input parameters are invalid
81  */
82 #define utf8_utf16_strcpy(d, s) utf8_utf16_strncpy((d), (s), SIZE_MAX)
83
84 /**
85  * utf16_get() - get next UTF-16 code point from buffer
86  *
87  * @src:                pointer to current word, updated to point to next word
88  * Return:              code point, or 0 for end of string, or -1 if no legal
89  *                      code point is found. In case of an error src points to
90  *                      the incorrect word.
91  */
92 s32 utf16_get(const u16 **src);
93
94 /**
95  * utf16_put() - write UTF-16 code point to buffer
96  *
97  * @code:               code point
98  * @dst:                pointer to destination buffer, updated to next position
99  * Return:              -1 if the input parameters are invalid
100  */
101 int utf16_put(s32 code, u16 **dst);
102
103 /**
104  * utf16_strnlen() - length of a truncated utf-16 string
105  *
106  * @src:                utf-16 string
107  * @count:              maximum number of code points to convert
108  * Return:              length in code points. If an invalid UTF-16 sequence is
109  *                      hit one position will be reserved for a replacement
110  *                      character.
111  */
112 size_t utf16_strnlen(const u16 *src, size_t count);
113
114 /**
115  * utf16_utf8_strnlen() - length of a truncated utf-16 string after conversion
116  *                        to utf-8
117  *
118  * @src:                utf-16 string
119  * @count:              maximum number of code points to convert
120  * Return:              length in bytes after conversion to utf-8 without the
121  *                      trailing \0. If an invalid UTF-16 sequence is hit one
122  *                      byte will be reserved for a replacement character.
123  */
124 size_t utf16_utf8_strnlen(const u16 *src, size_t count);
125
126 /**
127  * utf16_utf8_strlen() - length of a utf-16 string after conversion to utf-8
128  *
129  * @src:                utf-16 string
130  * Return:              length in bytes after conversion to utf-8 without the
131  *                      trailing \0. If an invalid UTF-16 sequence is hit one
132  *                      byte will be reserved for a replacement character.
133  */
134 #define utf16_utf8_strlen(a) utf16_utf8_strnlen((a), SIZE_MAX)
135
136 /**
137  * utf16_utf8_strncpy() - copy utf-16 string to utf-8 string
138  *
139  * @dst:                destination buffer
140  * @src:                source buffer
141  * @count:              maximum number of code points to copy
142  * Return:              -1 if the input parameters are invalid
143  */
144 int utf16_utf8_strncpy(char **dst, const u16 *src, size_t count);
145
146 /**
147  * utf16_utf8_strcpy() - copy utf-16 string to utf-8 string
148  *
149  * @dst:                destination buffer
150  * @src:                source buffer
151  * Return:              -1 if the input parameters are invalid
152  */
153 #define utf16_utf8_strcpy(d, s) utf16_utf8_strncpy((d), (s), SIZE_MAX)
154
155 /**
156  * utf_to_lower() - convert a Unicode letter to lower case
157  *
158  * @code:               letter to convert
159  * Return:              lower case letter or unchanged letter
160  */
161 s32 utf_to_lower(const s32 code);
162
163 /**
164  * utf_to_upper() - convert a Unicode letter to upper case
165  *
166  * @code:               letter to convert
167  * Return:              upper case letter or unchanged letter
168  */
169 s32 utf_to_upper(const s32 code);
170
171 /*
172  * u16_strncmp() - compare two u16 string
173  *
174  * @s1:         first string to compare
175  * @s2:         second string to compare
176  * @n:          maximum number of u16 to compare
177  * Return:      0  if the first n u16 are the same in s1 and s2
178  *              < 0 if the first different u16 in s1 is less than the
179  *              corresponding u16 in s2
180  *              > 0 if the first different u16 in s1 is greater than the
181  *              corresponding u16 in s2
182  */
183 int u16_strncmp(const u16 *s1, const u16 *s2, size_t n);
184 #define u16_strcmp(s1, s2)      u16_strncmp((s1), (s2), SIZE_MAX)
185
186 /**
187  * u16_strlen - count non-zero words
188  *
189  * This function matches wsclen() if the -fshort-wchar compiler flag is set.
190  * In the EFI context we explicitly need a function handling u16 strings.
191  *
192  * @in:                 null terminated u16 string
193  * ReturnValue:         number of non-zero words.
194  *                      This is not the number of utf-16 letters!
195  */
196 size_t u16_strlen(const void *in);
197
198 /**
199  * u16_strlen - count non-zero words
200  *
201  * This function matches wscnlen_s() if the -fshort-wchar compiler flag is set.
202  * In the EFI context we explicitly need a function handling u16 strings.
203  *
204  * @in:                 null terminated u16 string
205  * @count:              maximum number of words to count
206  * ReturnValue:         number of non-zero words.
207  *                      This is not the number of utf-16 letters!
208  */
209 size_t u16_strnlen(const u16 *in, size_t count);
210
211 /**
212  * u16_strcpy() - copy u16 string
213  *
214  * Copy u16 string pointed to by src, including terminating null word, to
215  * the buffer pointed to by dest.
216  *
217  * @dest:               destination buffer
218  * @src:                source buffer (null terminated)
219  * Return:              'dest' address
220  */
221 u16 *u16_strcpy(u16 *dest, const u16 *src);
222
223 /**
224  * u16_strdup() - duplicate u16 string
225  *
226  * Copy u16 string pointed to by src, including terminating null word, to a
227  * newly allocated buffer.
228  *
229  * @src:                source buffer (null terminated)
230  * Return:              allocated new buffer on success, NULL on failure
231  */
232 u16 *u16_strdup(const void *src);
233
234 /**
235  * utf16_to_utf8() - Convert an utf16 string to utf8
236  *
237  * Converts 'size' characters of the utf16 string 'src' to utf8
238  * written to the 'dest' buffer.
239  *
240  * NOTE that a single utf16 character can generate up to 3 utf8
241  * characters.  See MAX_UTF8_PER_UTF16.
242  *
243  * @dest   the destination buffer to write the utf8 characters
244  * @src    the source utf16 string
245  * @size   the number of utf16 characters to convert
246  * @return the pointer to the first unwritten byte in 'dest'
247  */
248 uint8_t *utf16_to_utf8(uint8_t *dest, const uint16_t *src, size_t size);
249
250 #endif /* __CHARSET_H_ */