Rev 4175 | Rev 4198 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
4011 | svoboda | 1 | /* |
2 | * Copyright (c) 2001-2004 Jakub Jermar |
||
3 | * All rights reserved. |
||
4 | * |
||
5 | * Redistribution and use in source and binary forms, with or without |
||
6 | * modification, are permitted provided that the following conditions |
||
7 | * are met: |
||
8 | * |
||
9 | * - Redistributions of source code must retain the above copyright |
||
10 | * notice, this list of conditions and the following disclaimer. |
||
11 | * - Redistributions in binary form must reproduce the above copyright |
||
12 | * notice, this list of conditions and the following disclaimer in the |
||
13 | * documentation and/or other materials provided with the distribution. |
||
14 | * - The name of the author may not be used to endorse or promote products |
||
15 | * derived from this software without specific prior written permission. |
||
16 | * |
||
17 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
||
18 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
||
19 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
||
20 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
||
21 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
||
22 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||
23 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||
24 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||
25 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
||
26 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||
27 | */ |
||
28 | |||
4014 | decky | 29 | /** @addtogroup generic |
4011 | svoboda | 30 | * @{ |
31 | */ |
||
32 | |||
33 | /** |
||
34 | * @file |
||
4014 | decky | 35 | * @brief Miscellaneous functions. |
4011 | svoboda | 36 | */ |
37 | |||
38 | #include <string.h> |
||
39 | #include <print.h> |
||
40 | #include <cpu.h> |
||
41 | #include <arch/asm.h> |
||
42 | #include <arch.h> |
||
43 | #include <console/kconsole.h> |
||
44 | |||
4179 | decky | 45 | char invalch = '?'; |
46 | |||
4175 | decky | 47 | /** Decode a single UTF-8 character from a NULL-terminated string. |
48 | * |
||
49 | * Decode a single UTF-8 character from a plain char NULL-terminated |
||
50 | * string. Decoding starts at @index and this index is incremented |
||
51 | * if the current UTF-8 string is encoded in more than a single byte. |
||
52 | * |
||
53 | * @param str Plain character NULL-terminated string. |
||
54 | * @param index Index (counted in plain characters) where to start |
||
55 | * the decoding. |
||
4179 | decky | 56 | * @param limit Maximal allowed value of index. |
4175 | decky | 57 | * |
58 | * @return Decoded character in UTF-32 or '?' if the encoding is wrong. |
||
59 | * |
||
60 | */ |
||
4179 | decky | 61 | wchar_t utf8_decode(const char *str, index_t *index, index_t limit) |
4175 | decky | 62 | { |
63 | uint8_t c1; /* First plain character from str */ |
||
64 | uint8_t c2; /* Second plain character from str */ |
||
65 | uint8_t c3; /* Third plain character from str */ |
||
66 | uint8_t c4; /* Fourth plain character from str */ |
||
67 | |||
4179 | decky | 68 | if (*index > limit) |
69 | return invalch; |
||
70 | |||
4175 | decky | 71 | c1 = (uint8_t) str[*index]; |
72 | |||
73 | if ((c1 & 0x80) == 0) { |
||
74 | /* Plain ASCII (code points 0 .. 127) */ |
||
75 | return (wchar_t) c1; |
||
4179 | decky | 76 | } |
77 | |||
78 | if ((c1 & 0xe0) == 0xc0) { |
||
4175 | decky | 79 | /* Code points 128 .. 2047 */ |
4179 | decky | 80 | if (*index + 1 > limit) |
81 | return invalch; |
||
82 | |||
4175 | decky | 83 | c2 = (uint8_t) str[*index + 1]; |
84 | if ((c2 & 0xc0) == 0x80) { |
||
85 | (*index)++; |
||
86 | return ((wchar_t) ((c1 & 0x1f) << 6) | (c2 & 0x3f)); |
||
87 | } else |
||
4179 | decky | 88 | return invalch; |
89 | } |
||
90 | |||
91 | if ((c1 & 0xf0) == 0xe0) { |
||
4175 | decky | 92 | /* Code points 2048 .. 65535 */ |
4179 | decky | 93 | if (*index + 2 > limit) |
94 | return invalch; |
||
95 | |||
4175 | decky | 96 | c2 = (uint8_t) str[*index + 1]; |
97 | if ((c2 & 0xc0) == 0x80) { |
||
98 | (*index)++; |
||
99 | c3 = (uint8_t) str[*index + 1]; |
||
100 | if ((c3 & 0xc0) == 0x80) { |
||
101 | (*index)++; |
||
102 | return ((wchar_t) ((c1 & 0x0f) << 12) | ((c2 & 0x3f) << 6) | (c3 & 0x3f)); |
||
103 | } else |
||
4179 | decky | 104 | return invalch; |
4175 | decky | 105 | } else |
4179 | decky | 106 | return invalch; |
107 | } |
||
108 | |||
109 | if ((c1 & 0xf8) == 0xf0) { |
||
4175 | decky | 110 | /* Code points 65536 .. 1114111 */ |
4179 | decky | 111 | if (*index + 3 > limit) |
112 | return invalch; |
||
113 | |||
4175 | decky | 114 | c2 = (uint8_t) str[*index + 1]; |
115 | if ((c2 & 0xc0) == 0x80) { |
||
116 | (*index)++; |
||
117 | c3 = (uint8_t) str[*index + 1]; |
||
118 | if ((c3 & 0xc0) == 0x80) { |
||
119 | (*index)++; |
||
120 | c4 = (uint8_t) str[*index + 1]; |
||
121 | if ((c4 & 0xc0) == 0x80) { |
||
122 | (*index)++; |
||
123 | return ((wchar_t) ((c1 & 0x07) << 18) | ((c2 & 0x3f) << 12) | ((c3 & 0x3f) << 6) | (c4 & 0x3f)); |
||
124 | } else |
||
4179 | decky | 125 | return invalch; |
4175 | decky | 126 | } else |
4179 | decky | 127 | return invalch; |
4175 | decky | 128 | } else |
4179 | decky | 129 | return invalch; |
4175 | decky | 130 | } |
131 | |||
4179 | decky | 132 | return invalch; |
4175 | decky | 133 | } |
134 | |||
4179 | decky | 135 | /** Encode a single UTF-32 character as UTF-8 |
4011 | svoboda | 136 | * |
4179 | decky | 137 | * Encode a single UTF-32 character as UTF-8 and store it into |
138 | * the given buffer at @index. Encoding starts at @index and |
||
139 | * this index is incremented if the UTF-8 character takes |
||
140 | * more than a single byte. |
||
4011 | svoboda | 141 | * |
4179 | decky | 142 | * @param ch Input UTF-32 character. |
143 | * @param str Output buffer. |
||
144 | * @param index Index (counted in plain characters) where to start |
||
145 | * the encoding |
||
146 | * @param limit Maximal allowed value of index. |
||
147 | * |
||
148 | * @return True if the character was encoded or false if there is not |
||
149 | * enought space in the output buffer or the character is invalid |
||
150 | * Unicode code point. |
||
151 | * |
||
152 | */ |
||
153 | bool utf8_encode(const wchar_t ch, char *str, index_t *index, index_t limit) |
||
154 | { |
||
155 | if (*index > limit) |
||
156 | return false; |
||
157 | |||
158 | if ((ch >= 0) && (ch <= 127)) { |
||
159 | /* Plain ASCII (code points 0 .. 127) */ |
||
160 | str[*index] = ch & 0x7f; |
||
161 | return true; |
||
162 | } |
||
163 | |||
164 | if ((ch >= 128) && (ch <= 2047)) { |
||
165 | /* Code points 128 .. 2047 */ |
||
166 | if (*index + 1 > limit) |
||
167 | return false; |
||
168 | |||
169 | str[*index] = 0xc0 | ((ch >> 6) & 0x1f); |
||
170 | (*index)++; |
||
171 | str[*index] = 0x80 | (ch & 0x3f); |
||
172 | return true; |
||
173 | } |
||
174 | |||
175 | if ((ch >= 2048) && (ch <= 65535)) { |
||
176 | /* Code points 2048 .. 65535 */ |
||
177 | if (*index + 2 > limit) |
||
178 | return false; |
||
179 | |||
180 | str[*index] = 0xe0 | ((ch >> 12) & 0x0f); |
||
181 | (*index)++; |
||
182 | str[*index] = 0x80 | ((ch >> 6) & 0x3f); |
||
183 | (*index)++; |
||
184 | str[*index] = 0x80 | (ch & 0x3f); |
||
185 | return true; |
||
186 | } |
||
187 | |||
188 | if ((ch >= 65536) && (ch <= 1114111)) { |
||
189 | /* Code points 65536 .. 1114111 */ |
||
190 | if (*index + 3 > limit) |
||
191 | return false; |
||
192 | |||
193 | str[*index] = 0xf0 | ((ch >> 18) & 0x07); |
||
194 | (*index)++; |
||
195 | str[*index] = 0x80 | ((ch >> 12) & 0x3f); |
||
196 | (*index)++; |
||
197 | str[*index] = 0x80 | ((ch >> 6) & 0x3f); |
||
198 | (*index)++; |
||
199 | str[*index] = 0x80 | (ch & 0x3f); |
||
200 | return true; |
||
201 | } |
||
202 | |||
203 | return false; |
||
204 | } |
||
205 | |||
206 | /** Get bytes used by UTF-8 characters. |
||
207 | * |
||
208 | * Get the number of bytes (count of plain characters) which |
||
209 | * are used by a given count of UTF-8 characters in a string. |
||
210 | * As UTF-8 encoding is multibyte, there is no constant |
||
211 | * correspondence between number of characters and used bytes. |
||
212 | * |
||
213 | * @param str UTF-8 string to consider. |
||
214 | * @param count Number of UTF-8 characters to count. |
||
215 | * |
||
216 | * @return Number of bytes used by the characters. |
||
217 | * |
||
218 | */ |
||
219 | size_t utf8_count_bytes(const char *str, count_t count) |
||
220 | { |
||
221 | size_t size = 0; |
||
222 | index_t index = 0; |
||
223 | |||
224 | while ((utf8_decode(str, &index, UTF8_NO_LIMIT) != 0) && (size < count)) { |
||
225 | size++; |
||
226 | index++; |
||
227 | } |
||
228 | |||
229 | return index; |
||
230 | } |
||
231 | |||
232 | /** Check whether character is plain ASCII. |
||
233 | * |
||
234 | * @return True if character is plain ASCII. |
||
235 | * |
||
236 | */ |
||
237 | bool ascii_check(const wchar_t ch) |
||
238 | { |
||
239 | if ((ch >= 0) && (ch <= 127)) |
||
240 | return true; |
||
241 | |||
242 | return false; |
||
243 | } |
||
244 | |||
245 | /** Check whether character is Unicode. |
||
246 | * |
||
247 | * @return True if character is valid Unicode code point. |
||
248 | * |
||
249 | */ |
||
250 | bool unicode_check(const wchar_t ch) |
||
251 | { |
||
252 | if ((ch >= 0) && (ch <= 1114111)) |
||
253 | return true; |
||
254 | |||
255 | return false; |
||
256 | } |
||
257 | |||
258 | /** Return number of plain characters in a string. |
||
259 | * |
||
260 | * @param str NULL-terminated string. |
||
261 | * |
||
4011 | svoboda | 262 | * @return Number of characters in str. |
4014 | decky | 263 | * |
4011 | svoboda | 264 | */ |
265 | size_t strlen(const char *str) |
||
266 | { |
||
4179 | decky | 267 | size_t size; |
268 | for (size = 0; str[size]; size++); |
||
4011 | svoboda | 269 | |
4179 | decky | 270 | return size; |
271 | } |
||
272 | |||
273 | /** Return number of UTF-8 characters in a string. |
||
274 | * |
||
275 | * @param str NULL-terminated UTF-8 string. |
||
276 | * |
||
277 | * @return Number of UTF-8 characters in str. |
||
278 | * |
||
279 | */ |
||
280 | size_t strlen_utf8(const char *str) |
||
281 | { |
||
282 | size_t size = 0; |
||
283 | index_t index = 0; |
||
4011 | svoboda | 284 | |
4179 | decky | 285 | while (utf8_decode(str, &index, UTF8_NO_LIMIT) != 0) { |
286 | size++; |
||
287 | index++; |
||
288 | } |
||
289 | |||
290 | return size; |
||
4011 | svoboda | 291 | } |
292 | |||
4179 | decky | 293 | /** Return number of UTF-32 characters in a string. |
294 | * |
||
295 | * @param str NULL-terminated UTF-32 string. |
||
296 | * |
||
297 | * @return Number of UTF-32 characters in str. |
||
298 | * |
||
299 | */ |
||
300 | size_t strlen_utf32(const wchar_t *str) |
||
301 | { |
||
302 | size_t size; |
||
303 | for (size = 0; str[size]; size++); |
||
304 | |||
305 | return size; |
||
306 | } |
||
307 | |||
4011 | svoboda | 308 | /** Compare two NULL terminated strings |
309 | * |
||
310 | * Do a char-by-char comparison of two NULL terminated strings. |
||
311 | * The strings are considered equal iff they consist of the same |
||
312 | * characters on the minimum of their lengths. |
||
313 | * |
||
314 | * @param src First string to compare. |
||
315 | * @param dst Second string to compare. |
||
316 | * |
||
317 | * @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller. |
||
318 | * |
||
319 | */ |
||
320 | int strcmp(const char *src, const char *dst) |
||
321 | { |
||
322 | for (; *src && *dst; src++, dst++) { |
||
323 | if (*src < *dst) |
||
324 | return -1; |
||
325 | if (*src > *dst) |
||
326 | return 1; |
||
327 | } |
||
328 | if (*src == *dst) |
||
329 | return 0; |
||
4014 | decky | 330 | |
4011 | svoboda | 331 | if (!*src) |
332 | return -1; |
||
4014 | decky | 333 | |
4011 | svoboda | 334 | return 1; |
335 | } |
||
336 | |||
337 | |||
338 | /** Compare two NULL terminated strings |
||
339 | * |
||
340 | * Do a char-by-char comparison of two NULL terminated strings. |
||
341 | * The strings are considered equal iff they consist of the same |
||
342 | * characters on the minimum of their lengths and specified maximal |
||
343 | * length. |
||
344 | * |
||
345 | * @param src First string to compare. |
||
346 | * @param dst Second string to compare. |
||
347 | * @param len Maximal length for comparison. |
||
348 | * |
||
349 | * @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller. |
||
350 | * |
||
351 | */ |
||
352 | int strncmp(const char *src, const char *dst, size_t len) |
||
353 | { |
||
354 | unsigned int i; |
||
355 | |||
356 | for (i = 0; (*src) && (*dst) && (i < len); src++, dst++, i++) { |
||
357 | if (*src < *dst) |
||
358 | return -1; |
||
4014 | decky | 359 | |
4011 | svoboda | 360 | if (*src > *dst) |
361 | return 1; |
||
362 | } |
||
4014 | decky | 363 | |
4011 | svoboda | 364 | if (i == len || *src == *dst) |
365 | return 0; |
||
4014 | decky | 366 | |
4011 | svoboda | 367 | if (!*src) |
368 | return -1; |
||
4014 | decky | 369 | |
4011 | svoboda | 370 | return 1; |
371 | } |
||
372 | |||
373 | |||
374 | |||
375 | /** Copy NULL terminated string. |
||
376 | * |
||
377 | * Copy at most 'len' characters from string 'src' to 'dest'. |
||
378 | * If 'src' is shorter than 'len', '\0' is inserted behind the |
||
379 | * last copied character. |
||
380 | * |
||
4014 | decky | 381 | * @param src Source string. |
4011 | svoboda | 382 | * @param dest Destination buffer. |
4014 | decky | 383 | * @param len Size of destination buffer. |
384 | * |
||
4011 | svoboda | 385 | */ |
386 | void strncpy(char *dest, const char *src, size_t len) |
||
387 | { |
||
388 | unsigned int i; |
||
4014 | decky | 389 | |
4011 | svoboda | 390 | for (i = 0; i < len; i++) { |
391 | if (!(dest[i] = src[i])) |
||
392 | return; |
||
393 | } |
||
4014 | decky | 394 | |
4011 | svoboda | 395 | dest[i - 1] = '\0'; |
396 | } |
||
397 | |||
4012 | svoboda | 398 | /** Find first occurence of character in string. |
399 | * |
||
4014 | decky | 400 | * @param s String to search. |
401 | * @param i Character to look for. |
||
4012 | svoboda | 402 | * |
4014 | decky | 403 | * @return Pointer to character in @a s or NULL if not found. |
4012 | svoboda | 404 | */ |
405 | extern char *strchr(const char *s, int i) |
||
406 | { |
||
407 | while (*s != '\0') { |
||
4014 | decky | 408 | if (*s == i) |
409 | return (char *) s; |
||
4012 | svoboda | 410 | ++s; |
411 | } |
||
4014 | decky | 412 | |
4012 | svoboda | 413 | return NULL; |
414 | } |
||
415 | |||
4011 | svoboda | 416 | /** @} |
417 | */ |