0ab11810b48b3a2b2f47fbbc67cefe8358218503
[blender.git] / source / blender / blenlib / intern / string_utf8.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2011 Blender Foundation.
19  * Code from gutf8.c Copyright (C) 1999 Tom Tromey
20  *                   Copyright (C) 2000 Red Hat, Inc.
21  * All rights reserved.
22  *
23  * Contributor(s): Campbell Barton.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  *
27  */
28
29  /** \file blender/blenlib/intern/string_utf8.c
30   *  \ingroup bli
31   */
32
33 #include <string.h>
34 #include <wchar.h>
35 #include <wctype.h>
36 #include <wcwidth.h>
37 #include <stdio.h>
38 #include <stdlib.h>
39
40 #include "BLI_utildefines.h"
41
42 #include "BLI_string_utf8.h"  /* own include */
43
44 #ifdef __GNUC__
45 #  pragma GCC diagnostic error "-Wsign-conversion"
46 #endif
47
48 // #define DEBUG_STRSIZE
49
50 /* array copied from glib's gutf8.c, */
51 /* Note: last two values (0xfe and 0xff) are forbidden in utf-8, so they are considered 1 byte length too. */
52 static const size_t utf8_skip_data[256] = {
53         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
54         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
55         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
56         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
57         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
58         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
59         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
60         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 1, 1
61 };
62
63 /* from libswish3, originally called u8_isvalid(),
64  * modified to return the index of the bad character (byte index not utf).
65  * http://svn.swish-e.org/libswish3/trunk/src/libswish3/utf8.c r3044 - campbell */
66
67 /* based on the valid_utf8 routine from the PCRE library by Philip Hazel
68  *
69  * length is in bytes, since without knowing whether the string is valid
70  * it's hard to know how many characters there are! */
71
72 /**
73  * Find first utf-8 invalid byte in given \a str, of \a length bytes.
74  *
75  * \return the offset of the first invalid byte.
76  */
77 int BLI_utf8_invalid_byte(const char *str, int length)
78 {
79         const unsigned char *p, *perr, *pend = (const unsigned char *)str + length;
80         unsigned char c;
81         int ab;
82
83         for (p = (const unsigned char *)str; p < pend; p++, length--) {
84                 c = *p;
85                 perr = p;  /* Erroneous char is always the first of an invalid utf8 sequence... */
86                 if (ELEM(c, 0xfe, 0xff, 0x00))  /* Those three values are not allowed in utf8 string. */
87                         goto utf8_error;
88                 if (c < 128)
89                         continue;
90                 if ((c & 0xc0) != 0xc0)
91                         goto utf8_error;
92
93                 /* Note that since we always increase p (and decrease length) by one byte in main loop, we only add/subtract
94                  * extra utf8 bytes in code below
95                  * (ab number, aka number of bytes remaining in the utf8 sequence after the initial one). */
96                 ab = (int)utf8_skip_data[c] - 1;
97                 if (length <= ab) {
98                         goto utf8_error;
99                 }
100
101                 /* Check top bits in the second byte */
102                 p++;
103                 length--;
104                 if ((*p & 0xc0) != 0x80)
105                         goto utf8_error;
106
107                 /* Check for overlong sequences for each different length */
108                 switch (ab) {
109                         case 1:
110                                 /* Check for xx00 000x */
111                                 if ((c & 0x3e) == 0) goto utf8_error;
112                                 continue;   /* We know there aren't any more bytes to check */
113
114                         case 2:
115                                 /* Check for 1110 0000, xx0x xxxx */
116                                 if (c == 0xe0 && (*p & 0x20) == 0) goto utf8_error;
117                                 /* Some special cases, see section 5 of utf-8 decoder stress-test by Markus Kuhn
118                                  * (https://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt). */
119                                 /* From section 5.1 (and 5.2) */
120                                 if (c == 0xed) {
121                                         if (*p == 0xa0 && *(p + 1) == 0x80) goto utf8_error;
122                                         if (*p == 0xad && *(p + 1) == 0xbf) goto utf8_error;
123                                         if (*p == 0xae && *(p + 1) == 0x80) goto utf8_error;
124                                         if (*p == 0xaf && *(p + 1) == 0xbf) goto utf8_error;
125                                         if (*p == 0xb0 && *(p + 1) == 0x80) goto utf8_error;
126                                         if (*p == 0xbe && *(p + 1) == 0x80) goto utf8_error;
127                                         if (*p == 0xbf && *(p + 1) == 0xbf) goto utf8_error;
128                                 }
129                                 /* From section 5.3 */
130                                 if (c == 0xef) {
131                                         if (*p == 0xbf && *(p + 1) == 0xbe) goto utf8_error;
132                                         if (*p == 0xbf && *(p + 1) == 0xbf) goto utf8_error;
133                                 }
134                                 break;
135
136                         case 3:
137                                 /* Check for 1111 0000, xx00 xxxx */
138                                 if (c == 0xf0 && (*p & 0x30) == 0) goto utf8_error;
139                                 break;
140
141                         case 4:
142                                 /* Check for 1111 1000, xx00 0xxx */
143                                 if (c == 0xf8 && (*p & 0x38) == 0) goto utf8_error;
144                                 break;
145
146                         case 5:
147                                 /* Check for 1111 1100, xx00 00xx */
148                                 if (c == 0xfc && (*p & 0x3c) == 0) goto utf8_error;
149                                 break;
150                 }
151
152                 /* Check for valid bytes after the 2nd, if any; all must start 10 */
153                 while (--ab > 0) {
154                         p++;
155                         length--;
156                         if ((*p & 0xc0) != 0x80) goto utf8_error;
157                 }
158         }
159
160         return -1;
161
162 utf8_error:
163
164         return (int)((const char *)perr - (const char *)str);
165 }
166
167 int BLI_utf8_invalid_strip(char *str, int length)
168 {
169         int bad_char, tot = 0;
170
171         BLI_assert(str[length] == '\0');
172
173         while ((bad_char = BLI_utf8_invalid_byte(str, length)) != -1) {
174                 str += bad_char;
175                 length -= (bad_char + 1);
176
177                 if (length == 0) {
178                         /* last character bad, strip it */
179                         *str = '\0';
180                         tot++;
181                         break;
182                 }
183                 else {
184                         /* strip, keep looking */
185                         memmove(str, str + 1, (size_t)length + 1);  /* +1 for NULL char! */
186                         tot++;
187                 }
188         }
189
190         return tot;
191 }
192
193
194 /* compatible with BLI_strncpy, but esnure no partial utf8 chars */
195
196 #define BLI_STR_UTF8_CPY(dst, src, maxncpy)                                   \
197         {                                                                         \
198                 size_t utf8_size;                                                     \
199                 while (*src != '\0' && (utf8_size = utf8_skip_data[*src]) < maxncpy) {\
200                         maxncpy -= utf8_size;                                             \
201                         switch (utf8_size) {                                              \
202                                 case 6: *dst ++ = *src ++;                                    \
203                                 case 5: *dst ++ = *src ++;                                    \
204                                 case 4: *dst ++ = *src ++;                                    \
205                                 case 3: *dst ++ = *src ++;                                    \
206                                 case 2: *dst ++ = *src ++;                                    \
207                                 case 1: *dst ++ = *src ++;                                    \
208                         }                                                                 \
209                 }                                                                     \
210                 *dst = '\0';                                                          \
211         } (void)0
212
213 char *BLI_strncpy_utf8(char *__restrict dst, const char *__restrict src, size_t maxncpy)
214 {
215         char *r_dst = dst;
216
217         BLI_assert(maxncpy != 0);
218
219 #ifdef DEBUG_STRSIZE
220         memset(dst, 0xff, sizeof(*dst) * maxncpy);
221 #endif
222
223         /* note: currently we don't attempt to deal with invalid utf8 chars */
224         BLI_STR_UTF8_CPY(dst, src, maxncpy);
225
226         return r_dst;
227 }
228
229 size_t BLI_strncpy_utf8_rlen(char *__restrict dst, const char *__restrict src, size_t maxncpy)
230 {
231         char *r_dst = dst;
232
233         BLI_assert(maxncpy != 0);
234
235 #ifdef DEBUG_STRSIZE
236         memset(dst, 0xff, sizeof(*dst) * maxncpy);
237 #endif
238
239         /* note: currently we don't attempt to deal with invalid utf8 chars */
240         BLI_STR_UTF8_CPY(dst, src, maxncpy);
241
242         return (size_t)(dst - r_dst);
243 }
244
245 char *BLI_strncat_utf8(char *__restrict dst, const char *__restrict src, size_t maxncpy)
246 {
247         while (*dst && maxncpy > 0) {
248                 dst++;
249                 maxncpy--;
250         }
251
252 #ifdef DEBUG_STRSIZE
253         memset(dst, 0xff, sizeof(*dst) * maxncpy);
254 #endif
255
256         BLI_STR_UTF8_CPY(dst, src, maxncpy);
257
258         return dst;
259 }
260
261 #undef BLI_STR_UTF8_CPY
262
263 /* --------------------------------------------------------------------------*/
264 /* wchar_t / utf8 functions  */
265
266 size_t BLI_strncpy_wchar_as_utf8(char *__restrict dst, const wchar_t *__restrict src, const size_t maxncpy)
267 {
268         const size_t maxlen = maxncpy - 1;
269         const int64_t maxlen_secured = (int64_t)maxlen - 6;  /* 6 is max utf8 length of an unicode char. */
270         size_t len = 0;
271
272         BLI_assert(maxncpy != 0);
273
274 #ifdef DEBUG_STRSIZE
275         memset(dst, 0xff, sizeof(*dst) * maxncpy);
276 #endif
277
278         while (*src && len <= maxlen_secured) {
279                 len += BLI_str_utf8_from_unicode((unsigned int)*src++, dst + len);
280         }
281
282         /* We have to be more careful for the last six bytes, to avoid buffer overflow in case utf8-encoded char
283          * would be too long for our dst buffer. */
284         while (*src) {
285                 char t[6];
286                 size_t l = BLI_str_utf8_from_unicode((unsigned int)*src++, t);
287                 BLI_assert(l <= 6);
288                 if (len + l > maxlen) {
289                         break;
290                 }
291                 memcpy(dst + len, t, l);
292                 len += l;
293         }
294
295         dst[len] = '\0';
296
297         return len;
298 }
299
300 /* wchar len in utf8 */
301 size_t BLI_wstrlen_utf8(const wchar_t *src)
302 {
303         size_t len = 0;
304
305         while (*src) {
306                 len += BLI_str_utf8_from_unicode((unsigned int)*src++, NULL);
307         }
308
309         return len;
310 }
311
312 size_t BLI_strlen_utf8_ex(const char *strc, size_t *r_len_bytes)
313 {
314         size_t len;
315         const char *strc_orig = strc;
316
317         for (len = 0; *strc; len++)
318                 strc += BLI_str_utf8_size_safe(strc);
319
320         *r_len_bytes = (size_t)(strc - strc_orig);
321         return len;
322 }
323
324 size_t BLI_strlen_utf8(const char *strc)
325 {
326         size_t len;
327
328         for (len = 0; *strc; len++)
329                 strc += BLI_str_utf8_size_safe(strc);
330
331         return len;
332 }
333
334 size_t BLI_strnlen_utf8_ex(const char *strc, const size_t maxlen, size_t *r_len_bytes)
335 {
336         size_t len;
337         const char *strc_orig = strc;
338         const char *strc_end = strc + maxlen;
339
340         for (len = 0; *strc && strc < strc_end; len++) {
341                 strc += BLI_str_utf8_size_safe(strc);
342         }
343
344         *r_len_bytes = (size_t)(strc - strc_orig);
345         return len;
346 }
347
348 /**
349  * \param strc: the string to measure the length.
350  * \param maxlen: the string length (in bytes)
351  * \return the unicode length (not in bytes!)
352  */
353 size_t BLI_strnlen_utf8(const char *strc, const size_t maxlen)
354 {
355         size_t len;
356         const char *strc_end = strc + maxlen;
357
358         for (len = 0; *strc && strc < strc_end; len++) {
359                 strc += BLI_str_utf8_size_safe(strc);
360         }
361
362         return len;
363 }
364
365 size_t BLI_strncpy_wchar_from_utf8(wchar_t *__restrict dst_w, const char *__restrict src_c, const size_t maxncpy)
366 {
367         const size_t maxlen = maxncpy - 1;
368         size_t len = 0;
369
370         BLI_assert(maxncpy != 0);
371
372 #ifdef DEBUG_STRSIZE
373         memset(dst_w, 0xff, sizeof(*dst_w) * maxncpy);
374 #endif
375
376         while (*src_c && len != maxlen) {
377                 size_t step = 0;
378                 unsigned int unicode = BLI_str_utf8_as_unicode_and_size(src_c, &step);
379                 if (unicode != BLI_UTF8_ERR) {
380                         *dst_w = (wchar_t)unicode;
381                         src_c += step;
382                 }
383                 else {
384                         *dst_w = '?';
385                         src_c = BLI_str_find_next_char_utf8(src_c, NULL);
386                 }
387                 dst_w++;
388                 len++;
389         }
390
391         *dst_w = 0;
392
393         return len;
394 }
395
396 /* end wchar_t / utf8 functions  */
397 /* --------------------------------------------------------------------------*/
398
399 /* count columns that character/string occupies, based on wcwidth.c */
400
401 int BLI_wcwidth(wchar_t ucs)
402 {
403         return mk_wcwidth(ucs);
404 }
405
406 int BLI_wcswidth(const wchar_t *pwcs, size_t n)
407 {
408         return mk_wcswidth(pwcs, n);
409 }
410
411 int BLI_str_utf8_char_width(const char *p)
412 {
413         unsigned int unicode = BLI_str_utf8_as_unicode(p);
414         if (unicode == BLI_UTF8_ERR)
415                 return -1;
416
417         return BLI_wcwidth((wchar_t)unicode);
418 }
419
420 int BLI_str_utf8_char_width_safe(const char *p)
421 {
422         int columns;
423
424         unsigned int unicode = BLI_str_utf8_as_unicode(p);
425         if (unicode == BLI_UTF8_ERR)
426                 return 1;
427
428         columns = BLI_wcwidth((wchar_t)unicode);
429
430         return (columns < 0) ? 1 : columns;
431 }
432
433 /* --------------------------------------------------------------------------*/
434
435 /* copied from glib's gutf8.c, added 'Err' arg */
436
437 /* note, glib uses unsigned int for unicode, best we do the same,
438  * though we don't typedef it - campbell */
439
440 #define UTF8_COMPUTE(Char, Mask, Len, Err)                                    \
441         if (Char < 128) {                                                         \
442                 Len = 1;                                                              \
443                 Mask = 0x7f;                                                          \
444         }                                                                         \
445         else if ((Char & 0xe0) == 0xc0) {                                         \
446                 Len = 2;                                                              \
447                 Mask = 0x1f;                                                          \
448         }                                                                         \
449         else if ((Char & 0xf0) == 0xe0) {                                         \
450                 Len = 3;                                                              \
451                 Mask = 0x0f;                                                          \
452         }                                                                         \
453         else if ((Char & 0xf8) == 0xf0) {                                         \
454                 Len = 4;                                                              \
455                 Mask = 0x07;                                                          \
456         }                                                                         \
457         else if ((Char & 0xfc) == 0xf8) {                                         \
458                 Len = 5;                                                              \
459                 Mask = 0x03;                                                          \
460         }                                                                         \
461         else if ((Char & 0xfe) == 0xfc) {                                         \
462                 Len = 6;                                                              \
463                 Mask = 0x01;                                                          \
464         }                                                                         \
465         else {                                                                    \
466                 Len = Err;  /* -1 is the typical error value or 1 to skip */          \
467         } (void)0
468
469 /* same as glib define but added an 'Err' arg */
470 #define UTF8_GET(Result, Chars, Count, Mask, Len, Err)                        \
471         (Result) = (Chars)[0] & (Mask);                                           \
472         for ((Count) = 1; (Count) < (Len); ++(Count)) {                           \
473                 if (((Chars)[(Count)] & 0xc0) != 0x80) {                              \
474                         (Result) = Err;                                                   \
475                         break;                                                            \
476                 }                                                                     \
477                 (Result) <<= 6;                                                       \
478                 (Result) |= ((Chars)[(Count)] & 0x3f);                                \
479         } (void)0
480
481
482 /* uses glib functions but not from glib */
483 /* gets the size of a single utf8 char */
484 int BLI_str_utf8_size(const char *p)
485 {
486         int mask = 0, len;
487         const unsigned char c = (unsigned char) *p;
488
489         UTF8_COMPUTE(c, mask, len, -1);
490
491         (void)mask; /* quiet warning */
492
493         return len;
494 }
495
496 /* use when we want to skip errors */
497 int BLI_str_utf8_size_safe(const char *p)
498 {
499         int mask = 0, len;
500         const unsigned char c = (unsigned char) *p;
501
502         UTF8_COMPUTE(c, mask, len, 1);
503
504         (void)mask; /* quiet warning */
505
506         return len;
507 }
508
509 /* was g_utf8_get_char */
510 /**
511  * BLI_str_utf8_as_unicode:
512  * \param p a pointer to Unicode character encoded as UTF-8
513  *
514  * Converts a sequence of bytes encoded as UTF-8 to a Unicode character.
515  * If \a p does not point to a valid UTF-8 encoded character, results are
516  * undefined. If you are not sure that the bytes are complete
517  * valid Unicode characters, you should use g_utf8_get_char_validated()
518  * instead.
519  *
520  * Return value: the resulting character
521  **/
522 unsigned int BLI_str_utf8_as_unicode(const char *p)
523 {
524         int i, len;
525         unsigned int mask = 0;
526         unsigned int result;
527         const unsigned char c = (unsigned char) *p;
528
529         UTF8_COMPUTE(c, mask, len, -1);
530         if (UNLIKELY(len == -1))
531                 return BLI_UTF8_ERR;
532         UTF8_GET(result, p, i, mask, len, BLI_UTF8_ERR);
533
534         return result;
535 }
536
537 /* variant that increments the length */
538 unsigned int BLI_str_utf8_as_unicode_and_size(const char *__restrict p, size_t *__restrict index)
539 {
540         int i, len;
541         unsigned mask = 0;
542         unsigned int result;
543         const unsigned char c = (unsigned char) *p;
544
545         UTF8_COMPUTE(c, mask, len, -1);
546         if (UNLIKELY(len == -1))
547                 return BLI_UTF8_ERR;
548         UTF8_GET(result, p, i, mask, len, BLI_UTF8_ERR);
549         *index += (size_t)len;
550         return result;
551 }
552
553 unsigned int BLI_str_utf8_as_unicode_and_size_safe(const char *__restrict p, size_t *__restrict index)
554 {
555         int i, len;
556         unsigned int mask = 0;
557         unsigned int result;
558         const unsigned char c = (unsigned char) *p;
559
560         UTF8_COMPUTE(c, mask, len, -1);
561         if (UNLIKELY(len == -1)) {
562                 *index += 1;
563                 return c;
564         }
565         UTF8_GET(result, p, i, mask, len, BLI_UTF8_ERR);
566         *index += (size_t)len;
567         return result;
568 }
569
570 /* another variant that steps over the index,
571  * note, currently this also falls back to latin1 for text drawing. */
572 unsigned int BLI_str_utf8_as_unicode_step(const char *__restrict p, size_t *__restrict index)
573 {
574         int i, len;
575         unsigned int mask = 0;
576         unsigned int result;
577         unsigned char c;
578
579         p += *index;
580         c = (unsigned char) *p;
581
582         UTF8_COMPUTE(c, mask, len, -1);
583         if (UNLIKELY(len == -1)) {
584                 /* when called with NULL end, result will never be NULL,
585                  * checks for a NULL character */
586                 const char *p_next = BLI_str_find_next_char_utf8(p, NULL);
587                 /* will never return the same pointer unless '\0',
588                  * eternal loop is prevented */
589                 *index += (size_t)(p_next - p);
590                 return BLI_UTF8_ERR;
591         }
592
593         /* this is tricky since there are a few ways we can bail out of bad unicode
594          * values, 3 possible solutions. */
595 #if 0
596         UTF8_GET(result, p, i, mask, len, BLI_UTF8_ERR);
597 #elif 1
598         /* WARNING: this is NOT part of glib, or supported by similar functions.
599          * this is added for text drawing because some filepaths can have latin1
600          * characters */
601         UTF8_GET(result, p, i, mask, len, BLI_UTF8_ERR);
602         if (result == BLI_UTF8_ERR) {
603                 len = 1;
604                 result = *p;
605         }
606         /* end warning! */
607 #else
608         /* without a fallback like '?', text drawing will stop on this value */
609         UTF8_GET(result, p, i, mask, len, '?');
610 #endif
611
612         *index += (size_t)len;
613         return result;
614 }
615
616 /* was g_unichar_to_utf8 */
617 /**
618  * BLI_str_utf8_from_unicode:
619  * \param c: a Unicode character code
620  * \param outbuf: output buffer, must have at least 6 bytes of space.
621  *       If %NULL, the length will be computed and returned
622  *       and nothing will be written to outbuf.
623  *
624  * Converts a single character to UTF-8.
625  *
626  * \return number of bytes written
627  **/
628 size_t BLI_str_utf8_from_unicode(unsigned int c, char *outbuf)
629 {
630         /* If this gets modified, also update the copy in g_string_insert_unichar() */
631         unsigned int len = 0;
632         unsigned int first;
633         unsigned int i;
634
635         if (c < 0x80) {
636                 first = 0;
637                 len = 1;
638         }
639         else if (c < 0x800) {
640                 first = 0xc0;
641                 len = 2;
642         }
643         else if (c < 0x10000) {
644                 first = 0xe0;
645                 len = 3;
646         }
647         else if (c < 0x200000) {
648                 first = 0xf0;
649                 len = 4;
650         }
651         else if (c < 0x4000000) {
652                 first = 0xf8;
653                 len = 5;
654         }
655         else {
656                 first = 0xfc;
657                 len = 6;
658         }
659
660         if (outbuf) {
661                 for (i = len - 1; i > 0; --i) {
662                         outbuf[i] = (c & 0x3f) | 0x80;
663                         c >>= 6;
664                 }
665                 outbuf[0] = c | first;
666         }
667
668         return len;
669 }
670
671 /* was g_utf8_find_prev_char */
672 /**
673  * BLI_str_find_prev_char_utf8:
674  * \param str pointer to the beginning of a UTF-8 encoded string
675  * \param p pointer to some position within \a str
676  *
677  * Given a position \a p with a UTF-8 encoded string \a str, find the start
678  * of the previous UTF-8 character starting before. \a p Returns %NULL if no
679  * UTF-8 characters are present in \a str before \a p
680  *
681  * \a p does not have to be at the beginning of a UTF-8 character. No check
682  * is made to see if the character found is actually valid other than
683  * it starts with an appropriate byte.
684  *
685  * Return value: a pointer to the found character or %NULL.
686  **/
687 char *BLI_str_find_prev_char_utf8(const char *str, const char *p)
688 {
689         for (--p; p >= str; --p) {
690                 if ((*p & 0xc0) != 0x80) {
691                         return (char *)p;
692                 }
693         }
694         return NULL;
695 }
696
697 /* was g_utf8_find_next_char */
698 /**
699  * BLI_str_find_next_char_utf8:
700  * \param p a pointer to a position within a UTF-8 encoded string
701  * \param end a pointer to the byte following the end of the string,
702  * or %NULL to indicate that the string is nul-terminated.
703  *
704  * Finds the start of the next UTF-8 character in the string after \a p
705  *
706  * \a p does not have to be at the beginning of a UTF-8 character. No check
707  * is made to see if the character found is actually valid other than
708  * it starts with an appropriate byte.
709  *
710  * Return value: a pointer to the found character or %NULL
711  **/
712 char *BLI_str_find_next_char_utf8(const char *p, const char *end)
713 {
714         if (*p) {
715                 if (end) {
716                         for (++p; p < end && (*p & 0xc0) == 0x80; ++p) {
717                                 /* do nothing */
718                         }
719                 }
720                 else {
721                         for (++p; (*p & 0xc0) == 0x80; ++p) {
722                                 /* do nothing */
723                         }
724                 }
725         }
726         return (p == end) ? NULL : (char *)p;
727 }
728
729 /* was g_utf8_prev_char */
730 /**
731  * BLI_str_prev_char_utf8:
732  * \param p a pointer to a position within a UTF-8 encoded string
733  *
734  * Finds the previous UTF-8 character in the string before \a p
735  *
736  * \a p does not have to be at the beginning of a UTF-8 character. No check
737  * is made to see if the character found is actually valid other than
738  * it starts with an appropriate byte. If \a p might be the first
739  * character of the string, you must use g_utf8_find_prev_char() instead.
740  *
741  * Return value: a pointer to the found character.
742  **/
743 char *BLI_str_prev_char_utf8(const char *p)
744 {
745         while (1) {
746                 p--;
747                 if ((*p & 0xc0) != 0x80) {
748                         return (char *)p;
749                 }
750         }
751 }
752 /* end glib copy */
753
754 size_t BLI_str_partition_utf8(const char *str, const unsigned int delim[], const char **sep, const char **suf)
755 {
756         return BLI_str_partition_ex_utf8(str, NULL, delim, sep, suf, false);
757 }
758
759 size_t BLI_str_rpartition_utf8(const char *str, const unsigned int delim[], const char **sep, const char **suf)
760 {
761         return BLI_str_partition_ex_utf8(str, NULL, delim, sep, suf, true);
762 }
763
764 size_t BLI_str_partition_ex_utf8(
765         const char *str, const char *end, const unsigned int delim[], const char **sep, const char **suf, const bool from_right)
766 {
767         const unsigned int *d;
768         const size_t str_len = end ? (size_t)(end - str) : strlen(str);
769         size_t index;
770
771         /* Note that here, we assume end points to a valid utf8 char! */
772         BLI_assert(end == NULL || (end >= str && (BLI_str_utf8_as_unicode(end) != BLI_UTF8_ERR)));
773
774         *suf = (char *)(str + str_len);
775
776         for (*sep = (char *)(from_right ? BLI_str_find_prev_char_utf8(str, str + str_len) : str), index = 0;
777              *sep >= str && (!end || *sep < end) && **sep != '\0';
778              *sep = (char *)(from_right ? BLI_str_find_prev_char_utf8(str, *sep) : str + index))
779         {
780                 const unsigned int c = BLI_str_utf8_as_unicode_and_size(*sep, &index);
781
782                 if (c == BLI_UTF8_ERR) {
783                         *suf = *sep = NULL;
784                         break;
785                 }
786
787                 for (d = delim; *d != '\0'; ++d) {
788                         if (*d == c) {
789                                 /* *suf is already correct in case from_right is true. */
790                                 if (!from_right)
791                                         *suf = (char *)(str + index);
792                                 return (size_t)(*sep - str);
793                         }
794                 }
795
796                 *suf = *sep;  /* Useful in 'from_right' case! */
797         }
798
799         *suf = *sep = NULL;
800         return str_len;
801 }