]> de.git.xonotic.org Git - xonotic/darkplaces.git/blob - utf8lib.c
f7dff508feedb1d0b8e2d564be1000342e835e87
[xonotic/darkplaces.git] / utf8lib.c
1 #include "quakedef.h"
2 #include "utf8lib.h"
3
4 /*
5 ================================================================================
6 Initialization of UTF-8 support and new cvars.
7 ================================================================================
8 */
9 // for compatibility this defaults to 0
10 cvar_t    utf8_enable = {CVAR_SAVE, "utf8_enable", "0", "Enable UTF-8 support. For compatibility, this is disabled by default in most games."};
11
12 void   u8_Init(void)
13 {
14         Cvar_RegisterVariable(&utf8_enable);
15 }
16
17 /*
18 ================================================================================
19 UTF-8 encoding and decoding functions follow.
20 ================================================================================
21 */
22
23 unsigned char utf8_lengths[256] = { // 0 = invalid
24         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // ascii characters
25         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
26         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
27         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
28         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
29         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
30         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
31         1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
32         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0x80 - 0xBF are within multibyte sequences
33         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // they could be interpreted as 2-byte starts but
34         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // the codepoint would be < 127
35         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
36         0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0 and C1 would also result in overlong encodings
37         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
38         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
39         4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
40         // with F5 the codepoint is above 0x10FFFF,
41         // F8-FB would start 5-byte sequences
42         // FC-FD would start 6-byte sequences
43         // ...
44 };
45 Uchar utf8_range[5] = {
46         1,       // invalid - let's not allow the creation of 0-bytes :P
47         1,       // ascii minimum
48         0x80,    // 2-byte minimum
49         0x800,   // 3-byte minimum
50         0x10000, // 4-byte minimum
51 };
52
53 /** Analyze the next character and return various information if requested.
54  * @param _s      An utf-8 string.
55  * @param _start  Filled with the start byte-offset of the next valid character
56  * @param _len    Fileed with the length of the next valid character
57  * @param _ch     Filled with the unicode value of the next character
58  * @param _maxlen Maximum number of bytes to read from _s
59  * @return        Whether or not another valid character is in the string
60  */
61 #define U8_ANALYZE_INFINITY 7
62 static qboolean u8_analyze(const char *_s, size_t *_start, size_t *_len, Uchar *_ch, size_t _maxlen)
63 {
64         const unsigned char *s = (const unsigned char*)_s;
65         unsigned char bt;//, bc;
66         size_t i;
67         size_t bits, j;
68         Uchar ch;
69
70         i = 0;
71 findchar:
72         while (i < _maxlen && s[i] && (bits = utf8_lengths[s[i]]) == 0)
73                 ++i;
74
75         if (i >= _maxlen || !s[i]) {
76                 if (_start) *_start = i;
77                 if (_len) *_len = 0;
78                 return false;
79         }
80         
81         if (bits == 1) { // ascii
82                 if (_start) *_start = i;
83                 if (_len) *_len = 1;
84                 if (_ch) *_ch = (Uchar)s[i];
85                 return true;
86         }
87
88         ch = (s[i] & (0xFF >> bits));
89         for (j = 1; j < bits; ++j)
90         {
91                 if ( (s[i+j] & 0xC0) != 0x80 )
92                 {
93                         i += j;
94                         goto findchar;
95                 }
96                 ch = (ch << 6) | (s[i+j] & 0x3F);
97         }
98         if (ch < utf8_range[bits] || ch >= 0x10FFFF)
99         {
100                 i += bits;
101                 goto findchar;
102         }
103 #if 0
104         // <0xC2 is always an overlong encoding, they're invalid, thus skipped
105         while (i < _maxlen && s[i] && s[i] >= 0x80 && s[i] < 0xC2) {
106                 //fprintf(stderr, "skipping\n");
107                 ++i;
108         }
109
110         // If we hit the end, well, we're out and invalid
111         if(i >= _maxlen || !s[i]) {
112                 if (_start) *_start = i;
113                 if (_len) *_len = 0;
114                 return false;
115         }
116
117         // I'll leave that in - if you remove it, also change the part below
118         // to support 1-byte chars correctly
119         if (s[i] < 0x80)
120         {
121                 if (_start) *_start = i;
122                 if (_len) *_len = 1;
123                 if (_ch) *_ch = (Uchar)s[i];
124                 //fprintf(stderr, "valid ascii\n");
125                 return true;
126         }
127
128         // Figure out the next char's length
129         bc = s[i];
130         bits = 1;
131         // count the 1 bits, they're the # of bytes
132         for (bt = 0x40; bt && (bc & bt); bt >>= 1, ++bits);
133         if (!bt)
134         {
135                 //fprintf(stderr, "superlong\n");
136                 ++i;
137                 goto findchar;
138         }
139         if(i + bits > _maxlen) {
140                 /*
141                 if (_start) *_start = i;
142                 if (_len) *_len = 0;
143                 return false;
144                 */
145                 ++i;
146                 goto findchar;
147         }
148         // turn bt into a mask and give ch a starting value
149         --bt;
150         ch = (s[i] & bt);
151         // check the byte sequence for invalid bytes
152         for (j = 1; j < bits; ++j)
153         {
154                 // valid bit value: 10xx xxxx
155                 //if (s[i+j] < 0x80 || s[i+j] >= 0xC0)
156                 if ( (s[i+j] & 0xC0) != 0x80 )
157                 {
158                         //fprintf(stderr, "sequence of %i f'd at %i by %x\n", bits, j, (unsigned int)s[i+j]);
159                         // this byte sequence is invalid, skip it
160                         i += j;
161                         // find a character after it
162                         goto findchar;
163                 }
164                 // at the same time, decode the character
165                 ch = (ch << 6) | (s[i+j] & 0x3F);
166         }
167
168         // Now check the decoded byte for an overlong encoding
169         if ( (bits >= 2 && ch < 0x80) ||
170              (bits >= 3 && ch < 0x800) ||
171              (bits >= 4 && ch < 0x10000) ||
172              ch >= 0x10FFFF // RFC 3629
173                 )
174         {
175                 i += bits;
176                 //fprintf(stderr, "overlong: %i bytes for %x\n", bits, ch);
177                 goto findchar;
178         }
179 #endif
180
181         if (_start)
182                 *_start = i;
183         if (_len)
184                 *_len = bits;
185         if (_ch)
186                 *_ch = ch;
187         //fprintf(stderr, "valid utf8\n");
188         return true;
189 }
190
191 /** Get the number of characters in an UTF-8 string.
192  * @param _s    An utf-8 encoded null-terminated string.
193  * @return      The number of unicode characters in the string.
194  */
195 size_t u8_strlen(const char *_s)
196 {
197         size_t st, ln;
198         size_t len = 0;
199         const unsigned char *s = (const unsigned char*)_s;
200
201         if (!utf8_enable.integer)
202                 return strlen(_s);
203
204         while (*s)
205         {
206                 // ascii char, skip u8_analyze
207                 if (*s < 0x80)
208                 {
209                         ++len;
210                         ++s;
211                         continue;
212                 }
213
214                 // invalid, skip u8_analyze
215                 if (*s < 0xC2)
216                 {
217                         ++s;
218                         continue;
219                 }
220
221                 if (!u8_analyze((const char*)s, &st, &ln, NULL, U8_ANALYZE_INFINITY))
222                         break;
223                 // valid character, skip after it
224                 s += st + ln;
225                 ++len;
226         }
227         return len;
228 }
229
230 /** Get the number of characters in a part of an UTF-8 string.
231  * @param _s    An utf-8 encoded null-terminated string.
232  * @param n     The maximum number of bytes.
233  * @return      The number of unicode characters in the string.
234  */
235 size_t u8_strnlen(const char *_s, size_t n)
236 {
237         size_t st, ln;
238         size_t len = 0;
239         const unsigned char *s = (const unsigned char*)_s;
240
241         if (!utf8_enable.integer)
242         {
243                 len = strlen(_s);
244                 return (len < n) ? len : n;
245         }
246
247         while (*s && n)
248         {
249                 // ascii char, skip u8_analyze
250                 if (*s < 0x80)
251                 {
252                         ++len;
253                         ++s;
254                         --n;
255                         continue;
256                 }
257
258                 // invalid, skip u8_analyze
259                 if (*s < 0xC2)
260                 {
261                         ++s;
262                         --n;
263                         continue;
264                 }
265
266                 if (!u8_analyze((const char*)s, &st, &ln, NULL, n))
267                         break;
268                 // valid character, see if it's still inside the range specified by n:
269                 if (n < st + ln)
270                         return len;
271                 ++len;
272                 n -= st + ln;
273                 s += st + ln;
274         }
275         return len;
276 }
277
278 /** Get the number of bytes used in a string to represent an amount of characters.
279  * @param _s    An utf-8 encoded null-terminated string.
280  * @param n     The number of characters we want to know the byte-size for.
281  * @return      The number of bytes used to represent n characters.
282  */
283 size_t u8_bytelen(const char *_s, size_t n)
284 {
285         size_t st, ln;
286         size_t len = 0;
287         const unsigned char *s = (const unsigned char*)_s;
288
289         if (!utf8_enable.integer) {
290                 len = strlen(_s);
291                 return (len < n) ? len : n;
292         }
293
294         while (*s && n)
295         {
296                 // ascii char, skip u8_analyze
297                 if (*s < 0x80)
298                 {
299                         ++len;
300                         ++s;
301                         --n;
302                         continue;
303                 }
304
305                 // invalid, skip u8_analyze
306                 if (*s < 0xC2)
307                 {
308                         ++s;
309                         ++len;
310                         continue;
311                 }
312
313                 if (!u8_analyze((const char*)s, &st, &ln, NULL, U8_ANALYZE_INFINITY))
314                         break;
315                 --n;
316                 s += st + ln;
317                 len += st + ln;
318         }
319         return len;
320 }
321
322 /** Get the byte-index for a character-index.
323  * @param _s      An utf-8 encoded string.
324  * @param i       The character-index for which you want the byte offset.
325  * @param len     If not null, character's length will be stored in there.
326  * @return        The byte-index at which the character begins, or -1 if the string is too short.
327  */
328 int u8_byteofs(const char *_s, size_t i, size_t *len)
329 {
330         size_t st, ln;
331         size_t ofs = 0;
332         const unsigned char *s = (const unsigned char*)_s;
333
334         if (!utf8_enable.integer)
335         {
336                 if (strlen(_s) < i)
337                 {
338                         if (len) *len = 0;
339                         return -1;
340                 }
341
342                 if (len) *len = 1;
343                 return i;
344         }
345
346         st = ln = 0;
347         do
348         {
349                 ofs += ln;
350                 if (!u8_analyze((const char*)s + ofs, &st, &ln, NULL, U8_ANALYZE_INFINITY))
351                         return -1;
352                 ofs += st;
353         } while(i-- > 0);
354         if (len)
355                 *len = ln;
356         return ofs;
357 }
358
359 /** Get the char-index for a byte-index.
360  * @param _s      An utf-8 encoded string.
361  * @param i       The byte offset for which you want the character index.
362  * @param len     If not null, the offset within the character is stored here.
363  * @return        The character-index, or -1 if the string is too short.
364  */
365 int u8_charidx(const char *_s, size_t i, size_t *len)
366 {
367         size_t st, ln;
368         size_t ofs = 0;
369         size_t pofs = 0;
370         int idx = 0;
371         const unsigned char *s = (const unsigned char*)_s;
372
373         if (!utf8_enable.integer)
374         {
375                 if (len) *len = 0;
376                 return i;
377         }
378
379         while (ofs < i && s[ofs])
380         {
381                 // ascii character, skip u8_analyze
382                 if (s[ofs] < 0x80)
383                 {
384                         pofs = ofs;
385                         ++idx;
386                         ++ofs;
387                         continue;
388                 }
389
390                 // invalid, skip u8_analyze
391                 if (s[ofs] < 0xC2)
392                 {
393                         ++ofs;
394                         continue;
395                 }
396
397                 if (!u8_analyze((const char*)s+ofs, &st, &ln, NULL, U8_ANALYZE_INFINITY))
398                         return -1;
399                 // see if next char is after the bytemark
400                 if (ofs + st > i)
401                 {
402                         if (len)
403                                 *len = i - pofs;
404                         return idx;
405                 }
406                 ++idx;
407                 pofs = ofs + st;
408                 ofs += st + ln;
409                 // see if bytemark is within the char
410                 if (ofs > i)
411                 {
412                         if (len)
413                                 *len = i - pofs;
414                         return idx;
415                 }
416         }
417         if (len) *len = 0;
418         return idx;
419 }
420
421 /** Get the byte offset of the previous byte.
422  * The result equals:
423  * prevchar_pos = u8_byteofs(text, u8_charidx(text, thischar_pos, NULL) - 1, NULL)
424  * @param _s      An utf-8 encoded string.
425  * @param i       The current byte offset.
426  * @return        The byte offset of the previous character
427  */
428 size_t u8_prevbyte(const char *_s, size_t i)
429 {
430         size_t st, ln;
431         const unsigned char *s = (const unsigned char*)_s;
432         size_t lastofs = 0;
433         size_t ofs = 0;
434
435         if (!utf8_enable.integer)
436         {
437                 if (i > 0)
438                         return i-1;
439                 return 0;
440         }
441
442         while (ofs < i && s[ofs])
443         {
444                 // ascii character, skip u8_analyze
445                 if (s[ofs] < 0x80)
446                 {
447                         lastofs = ofs++;
448                         continue;
449                 }
450
451                 // invalid, skip u8_analyze
452                 if (s[ofs] < 0xC2)
453                 {
454                         ++ofs;
455                         continue;
456                 }
457
458                 if (!u8_analyze((const char*)s+ofs, &st, &ln, NULL, U8_ANALYZE_INFINITY))
459                         return lastofs;
460                 if (ofs + st > i)
461                         return lastofs;
462                 if (ofs + st + ln >= i)
463                         return ofs + st;
464
465                 lastofs = ofs;
466                 ofs += st + ln;
467         }
468         return lastofs;
469 }
470
471 Uchar u8_quake2utf8map[256] = {
472         0xE000, 0xE001, 0xE002, 0xE003, 0xE004, 0xE005, 0xE006, 0xE007, 0xE008, 0xE009, 0xE00A, 0xE00B, 0xE00C, 0xE00D, 0xE00E, 0xE00F, // specials
473         0xE010, 0xE011, 0xE012, 0xE013, 0xE014, 0xE015, 0xE016, 0xE017, 0xE018, 0xE019, 0xE01A, 0xE01B, 0xE01C, 0xE01D, 0xE01E, 0xE01F, // specials
474         0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027, 0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F, // shift+digit line
475         0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, 0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F, // digits
476         0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, 0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, // caps
477         0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F, // caps
478         0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, 0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, // small
479         0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F, // small
480         0xE080, 0xE081, 0xE082, 0xE083, 0xE084, 0xE085, 0xE086, 0xE087, 0xE088, 0xE089, 0xE08A, 0xE08B, 0xE08C, 0xE08D, 0xE08E, 0xE08F, // specials
481         0xE090, 0xE091, 0xE092, 0xE093, 0xE094, 0xE095, 0xE096, 0xE097, 0xE098, 0xE099, 0xE09A, 0xE09B, 0xE09C, 0xE09D, 0xE09E, 0xE09F, // faces
482         0xE0A0, 0xE0A1, 0xE0A2, 0xE0A3, 0xE0A4, 0xE0A5, 0xE0A6, 0xE0A7, 0xE0A8, 0xE0A9, 0xE0AA, 0xE0AB, 0xE0AC, 0xE0AD, 0xE0AE, 0xE0AF,
483         0xE0B0, 0xE0B1, 0xE0B2, 0xE0B3, 0xE0B4, 0xE0B5, 0xE0B6, 0xE0B7, 0xE0B8, 0xE0B9, 0xE0BA, 0xE0BB, 0xE0BC, 0xE0BD, 0xE0BE, 0xE0BF,
484         0xE0C0, 0xE0C1, 0xE0C2, 0xE0C3, 0xE0C4, 0xE0C5, 0xE0C6, 0xE0C7, 0xE0C8, 0xE0C9, 0xE0CA, 0xE0CB, 0xE0CC, 0xE0CD, 0xE0CE, 0xE0CF,
485         0xE0D0, 0xE0D1, 0xE0D2, 0xE0D3, 0xE0D4, 0xE0D5, 0xE0D6, 0xE0D7, 0xE0D8, 0xE0D9, 0xE0DA, 0xE0DB, 0xE0DC, 0xE0DD, 0xE0DE, 0xE0DF,
486         0xE0E0, 0xE0E1, 0xE0E2, 0xE0E3, 0xE0E4, 0xE0E5, 0xE0E6, 0xE0E7, 0xE0E8, 0xE0E9, 0xE0EA, 0xE0EB, 0xE0EC, 0xE0ED, 0xE0EE, 0xE0EF,
487         0xE0F0, 0xE0F1, 0xE0F2, 0xE0F3, 0xE0F4, 0xE0F5, 0xE0F6, 0xE0F7, 0xE0F8, 0xE0F9, 0xE0FA, 0xE0FB, 0xE0FC, 0xE0FD, 0xE0FE, 0xE0FF,
488 };
489
490 /** Fetch a character from an utf-8 encoded string.
491  * @param _s      The start of an utf-8 encoded multi-byte character.
492  * @param _end    Will point to after the first multi-byte character.
493  * @return        The 32-bit integer representation of the first multi-byte character or 0 for invalid characters.
494  */
495 Uchar u8_getchar_utf8_enabled(const char *_s, const char **_end)
496 {
497         size_t st, ln;
498         Uchar ch;
499
500         if (!u8_analyze(_s, &st, &ln, &ch, U8_ANALYZE_INFINITY))
501                 ch = 0;
502         if (_end)
503                 *_end = _s + st + ln;
504         return ch;
505 }
506
507 /** Fetch a character from an utf-8 encoded string.
508  * @param _s      The start of an utf-8 encoded multi-byte character.
509  * @param _end    Will point to after the first multi-byte character.
510  * @return        The 32-bit integer representation of the first multi-byte character or 0 for invalid characters.
511  */
512 Uchar u8_getnchar_utf8_enabled(const char *_s, const char **_end, size_t _maxlen)
513 {
514         size_t st, ln;
515         Uchar ch;
516
517         if (!u8_analyze(_s, &st, &ln, &ch, _maxlen))
518                 ch = 0;
519         if (_end)
520                 *_end = _s + st + ln;
521         return ch;
522 }
523
524 /** Encode a wide-character into utf-8.
525  * @param w        The wide character to encode.
526  * @param to       The target buffer the utf-8 encoded string is stored to.
527  * @param maxlen   The maximum number of bytes that fit into the target buffer.
528  * @return         Number of bytes written to the buffer not including the terminating null.
529  *                 Less or equal to 0 if the buffer is too small.
530  */
531 int u8_fromchar(Uchar w, char *to, size_t maxlen)
532 {
533         if (maxlen < 1)
534                 return 0;
535
536         if (!w)
537                 return 0;
538
539         if (w >= 0xE000 && !utf8_enable.integer)
540                 w -= 0xE000;
541
542         if (w < 0x80 || !utf8_enable.integer)
543         {
544                 to[0] = (char)w;
545                 if (maxlen < 2)
546                         return -1;
547                 to[1] = 0;
548                 return 1;
549         }
550         // for a little speedup
551         if (w < 0x800)
552         {
553                 if (maxlen < 3)
554                 {
555                         to[0] = 0;
556                         return -1;
557                 }
558                 to[2] = 0;
559                 to[1] = 0x80 | (w & 0x3F); w >>= 6;
560                 to[0] = 0xC0 | w;
561                 return 2;
562         }
563         if (w < 0x10000)
564         {
565                 if (maxlen < 4)
566                 {
567                         to[0] = 0;
568                         return -1;
569                 }
570                 to[3] = 0;
571                 to[2] = 0x80 | (w & 0x3F); w >>= 6;
572                 to[1] = 0x80 | (w & 0x3F); w >>= 6;
573                 to[0] = 0xE0 | w;
574                 return 3;
575         }
576
577         // RFC 3629
578         if (w <= 0x10FFFF)
579         {
580                 if (maxlen < 5)
581                 {
582                         to[0] = 0;
583                         return -1;
584                 }
585                 to[4] = 0;
586                 to[3] = 0x80 | (w & 0x3F); w >>= 6;
587                 to[2] = 0x80 | (w & 0x3F); w >>= 6;
588                 to[1] = 0x80 | (w & 0x3F); w >>= 6;
589                 to[0] = 0xE0 | w;
590                 return 4;
591         }
592         return 0;
593 }
594
595 /** uses u8_fromchar on a static buffer
596  * @param ch        The unicode character to convert to encode
597  * @param l         The number of bytes without the terminating null.
598  * @return          A statically allocated buffer containing the character's utf8 representation, or NULL if it fails.
599  */
600 char *u8_encodech(Uchar ch, size_t *l)
601 {
602         static char buf[16];
603         size_t len;
604         len = u8_fromchar(ch, buf, sizeof(buf));
605         if (len > 0)
606         {
607                 if (l) *l = len;
608                 return buf;
609         }
610         return NULL;
611 }
612
613 /** Convert a utf-8 multibyte string to a wide character string.
614  * @param wcs       The target wide-character buffer.
615  * @param mb        The utf-8 encoded multibyte string to convert.
616  * @param maxlen    The maximum number of wide-characters that fit into the target buffer.
617  * @return          The number of characters written to the target buffer.
618  */
619 size_t u8_mbstowcs(Uchar *wcs, const char *mb, size_t maxlen)
620 {
621         size_t i;
622         Uchar ch;
623         if (maxlen < 1)
624                 return 0;
625         for (i = 0; *mb && i < maxlen-1; ++i)
626         {
627                 ch = u8_getchar(mb, &mb);
628                 if (!ch)
629                         break;
630                 wcs[i] = ch;
631         }
632         wcs[i] = 0;
633         return i;
634 }
635
636 /** Convert a wide-character string to a utf-8 multibyte string.
637  * @param mb      The target buffer the utf-8 string is written to.
638  * @param wcs     The wide-character string to convert.
639  * @param maxlen  The number bytes that fit into the multibyte target buffer.
640  * @return        The number of bytes written, not including the terminating \0
641  */
642 size_t u8_wcstombs(char *mb, const Uchar *wcs, size_t maxlen)
643 {
644         size_t i;
645         const char *start = mb;
646         if (maxlen < 2)
647                 return 0;
648         for (i = 0; wcs[i] && i < maxlen-1; ++i)
649         {
650                 /*
651                 int len;
652                 if ( (len = u8_fromchar(wcs[i], mb, maxlen - i)) < 0)
653                         return (mb - start);
654                 mb += len;
655                 */
656                 mb += u8_fromchar(wcs[i], mb, maxlen - i);
657         }
658         *mb = 0;
659         return (mb - start);
660 }
661
662 /*
663 ============
664 UTF-8 aware COM_StringLengthNoColors
665
666 calculates the visible width of a color coded string.
667
668 *valid is filled with TRUE if the string is a valid colored string (that is, if
669 it does not end with an unfinished color code). If it gets filled with FALSE, a
670 fix would be adding a STRING_COLOR_TAG at the end of the string.
671
672 valid can be set to NULL if the caller doesn't care.
673
674 For size_s, specify the maximum number of characters from s to use, or 0 to use
675 all characters until the zero terminator.
676 ============
677 */
678 size_t
679 COM_StringLengthNoColors(const char *s, size_t size_s, qboolean *valid);
680 size_t
681 u8_COM_StringLengthNoColors(const char *_s, size_t size_s, qboolean *valid)
682 {
683         const unsigned char *s = (const unsigned char*)_s;
684         const unsigned char *end;
685         size_t len = 0;
686
687         if (!utf8_enable.integer)
688                 return COM_StringLengthNoColors(_s, size_s, valid);
689
690         end = size_s ? (s + size_s) : NULL;
691
692         for(;;)
693         {
694                 switch((s == end) ? 0 : *s)
695                 {
696                         case 0:
697                                 if(valid)
698                                         *valid = TRUE;
699                                 return len;
700                         case STRING_COLOR_TAG:
701                                 ++s;
702                                 switch((s == end) ? 0 : *s)
703                                 {
704                                         case STRING_COLOR_RGB_TAG_CHAR:
705                                                 if (s+1 != end && isxdigit(s[1]) &&
706                                                         s+2 != end && isxdigit(s[2]) &&
707                                                         s+3 != end && isxdigit(s[3]) )
708                                                 {
709                                                         s+=3;
710                                                         break;
711                                                 }
712                                                 ++len; // STRING_COLOR_TAG
713                                                 ++len; // STRING_COLOR_RGB_TAG_CHAR
714                                                 break;
715                                         case 0: // ends with unfinished color code!
716                                                 ++len;
717                                                 if(valid)
718                                                         *valid = FALSE;
719                                                 return len;
720                                         case STRING_COLOR_TAG: // escaped ^
721                                                 ++len;
722                                                 break;
723                                         case '0': case '1': case '2': case '3': case '4':
724                                         case '5': case '6': case '7': case '8': case '9': // color code
725                                                 break;
726                                         default: // not a color code
727                                                 ++len; // STRING_COLOR_TAG
728                                                 ++len; // the character
729                                                 break;
730                                 }
731                                 break;
732                         default:
733                                 ++len;
734                                 break;
735                 }
736
737                 // start of a wide character
738                 if (*s & 0xC0)
739                 {
740                         for (++s; *s >= 0x80 && *s <= 0xC0; ++s);
741                         continue;
742                 }
743                 // part of a wide character, we ignore that one
744                 if (*s <= 0xBF)
745                         --len;
746                 ++s;
747         }
748         // never get here
749 }
750
751 /** Pads a utf-8 string
752  * @param out     The target buffer the utf-8 string is written to.
753  * @param outsize The size of the target buffer, including the final NUL
754  * @param in      The input utf-8 buffer
755  * @param leftalign Left align the output string (by default right alignment is done)
756  * @param minwidth The minimum output width
757  * @param maxwidth The maximum output width
758  * @return        The number of bytes written, not including the terminating \0
759  */
760 size_t u8_strpad(char *out, size_t outsize, const char *in, qboolean leftalign, size_t minwidth, size_t maxwidth)
761 {
762         if(!utf8_enable.integer)
763         {
764                 return dpsnprintf(out, outsize, "%*.*s", leftalign ? -(int) minwidth : (int) minwidth, (int) maxwidth, in);
765         }
766         else
767         {
768                 size_t l = u8_bytelen(in, maxwidth);
769                 size_t actual_width = u8_strnlen(in, l);
770                 int pad = (actual_width >= minwidth) ? 0 : (minwidth - actual_width);
771                 int prec = l;
772                 int lpad = leftalign ? 0 : pad;
773                 int rpad = leftalign ? pad : 0;
774                 return dpsnprintf(out, outsize, "%*s%.*s%*s", lpad, "", prec, in, rpad, "");
775         }
776 }