nfkc.c

   1 /* nfkc.c       unicode normalization utilities
   2  * Copyright (C) 2002  Simon Josefsson
   3  *
   4  * This file is part of libstringprep.
   5  *
   6  * Libstringprep is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * Libstringprep is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with libstringprep; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  */
  21
  22 #include "internal.h"
  23
  24 /* This file contains functions from GLIB including gutf8.c and
  25  * gunidecomp.c, all with the following license.
  26  *
  27  *  Copyright (C) 1999, 2000 Tom Tromey
  28  *  Copyright 2000 Red Hat, Inc.
  29  *
  30  * The Gnome Library is free software; you can redistribute it and/or
  31  * modify it under the terms of the GNU Lesser General Public License as
  32  * published by the Free Software Foundation; either version 2 of the
  33  * License, or (at your option) any later version.
  34  *
  35  * The Gnome Library is distributed in the hope that it will be useful,
  36  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  37  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  38  * Lesser General Public License for more details.
  39  *
  40  * You should have received a copy of the GNU Lesser General Public
  41  * License along with the Gnome Library; see the file COPYING.LIB.  If not,
  42  * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  43  *   Boston, MA 02111-1307, USA.
  44  */
  45
  46 typedef enum
  47 {
  48   G_NORMALIZE_DEFAULT,
  49   G_NORMALIZE_NFD = G_NORMALIZE_DEFAULT,
  50   G_NORMALIZE_DEFAULT_COMPOSE,
  51   G_NORMALIZE_NFC = G_NORMALIZE_DEFAULT_COMPOSE,
  52   G_NORMALIZE_ALL,
  53   G_NORMALIZE_NFKD = G_NORMALIZE_ALL,
  54   G_NORMALIZE_ALL_COMPOSE,
  55   G_NORMALIZE_NFKC = G_NORMALIZE_ALL_COMPOSE
  56 }
  57 GNormalizeMode;
  58
  59 #include "gunidecomp.h"
  60 #include "gunicomp.h"
  61
  62 #define UTF8_COMPUTE(Char, Mask, Len)                                         \
  63   if (Char < 128)                                                             \
  64     {                                                                         \
  65       Len = 1;                                                                \
  66       Mask = 0x7f;                                                            \
  67     }                                                                         \
  68   else if ((Char & 0xe0) == 0xc0)                                             \
  69     {                                                                         \
  70       Len = 2;                                                                \
  71       Mask = 0x1f;                                                            \
  72     }                                                                         \
  73   else if ((Char & 0xf0) == 0xe0)                                             \
  74     {                                                                         \
  75       Len = 3;                                                                \
  76       Mask = 0x0f;                                                            \
  77     }                                                                         \
  78   else if ((Char & 0xf8) == 0xf0)                                             \
  79     {                                                                         \
  80       Len = 4;                                                                \
  81       Mask = 0x07;                                                            \
  82     }                                                                         \
  83   else if ((Char & 0xfc) == 0xf8)                                             \
  84     {                                                                         \
  85       Len = 5;                                                                \
  86       Mask = 0x03;                                                            \
  87     }                                                                         \
  88   else if ((Char & 0xfe) == 0xfc)                                             \
  89     {                                                                         \
  90       Len = 6;                                                                \
  91       Mask = 0x01;                                                            \
  92     }                                                                         \
  93   else                                                                        \
  94     Len = -1;
  95
  96 #define UTF8_LENGTH(Char)              \
  97   ((Char) < 0x80 ? 1 :                 \
  98    ((Char) < 0x800 ? 2 :               \
  99     ((Char) < 0x10000 ? 3 :            \
 100      ((Char) < 0x200000 ? 4 :          \
 101       ((Char) < 0x4000000 ? 5 : 6)))))
 102
 103
 104 #define UTF8_GET(Result, Chars, Count, Mask, Len)                             \
 105   (Result) = (Chars)[0] & (Mask);                                             \
 106   for ((Count) = 1; (Count) < (Len); ++(Count))                               \
 107     {                                                                         \
 108       if (((Chars)[(Count)] & 0xc0) != 0x80)                                  \
 109         {                                                                     \
 110           (Result) = -1;                                                      \
 111           break;                                                              \
 112         }                                                                     \
 113       (Result) <<= 6;                                                         \
 114       (Result) |= ((Chars)[(Count)] & 0x3f);                                  \
 115     }
 116
 117 #define UNICODE_VALID(Char)                   \
 118     ((Char) < 0x110000 &&                     \
 119      ((Char) < 0xD800 || (Char) >= 0xE000) && \
 120      (Char) != 0xFFFE && (Char) != 0xFFFF)
 121
 122 static const char utf8_skip_data[256] = {
 123   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,
 124   1, 1, 1, 1, 1, 1, 1,
 125   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,
 126   1, 1, 1, 1, 1, 1, 1,
 127   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,
 128   1, 1, 1, 1, 1, 1, 1,
 129   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,
 130   1, 1, 1, 1, 1, 1, 1,
 131   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,
 132   1, 1, 1, 1, 1, 1, 1,
 133   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,
 134   1, 1, 1, 1, 1, 1, 1,
 135   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,
 136   2, 2, 2, 2, 2, 2, 2,
 137   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,
 138   5, 5, 5, 6, 6, 1, 1
 139 };
 140 static const char *const g_utf8_skip = utf8_skip_data;
 141
 142 #define g_utf8_next_char(p) (char *)((p) + g_utf8_skip[*(unsigned char *)(p)])
 143
 144 /**
 145  * stringprep_utf8_to_unichar:
 146  * @p: a pointer to Unicode character encoded as UTF-8
 147  *
 148  * Converts a sequence of bytes encoded as UTF-8 to a Unicode character.
 149  * If @p does not point to a valid UTF-8 encoded character, results are
 150  * undefined.
 151  *
 152  * Return value: the resulting character
 153  **/
 154 long
 155 stringprep_utf8_to_unichar (const char *p)
 156 {
 157   int i, mask = 0, len;
 158   long result;
 159   unsigned char c = (unsigned char) *p;
 160
 161   UTF8_COMPUTE (c, mask, len);
 162   if (len == -1)
 163     return (long) -1;
 164   UTF8_GET (result, p, i, mask, len);
 165
 166   return result;
 167 }
 168
 169 #define CC(Page, Char) \
 170   ((combining_class_table[Page] >= G_UNICODE_MAX_TABLE_INDEX) \
 171    ? (combining_class_table[Page] - G_UNICODE_MAX_TABLE_INDEX) \
 172    : (cclass_data[combining_class_table[Page]][Char]))
 173
 174 #define COMBINING_CLASS(Char) \
 175      (((Char) > (G_UNICODE_LAST_CHAR)) ? 0 : CC((Char) >> 8, (Char) & 0xff))
 176
 177 /**
 178  * g_unicode_canonical_ordering:
 179  * @string: a UCS-4 encoded string.
 180  * @len: the maximum length of @string to use.
 181  *
 182  * Computes the canonical ordering of a string in-place.
 183  * This rearranges decomposed characters in the string
 184  * according to their combining classes.  See the Unicode
 185  * manual for more information.
 186  **/
 187 static void
 188 g_unicode_canonical_ordering (long *string, size_t len)
 189 {
 190   size_t i;
 191   int swap = 1;
 192
 193   while (swap)
 194     {
 195       int last;
 196       swap = 0;
 197       last = COMBINING_CLASS (string[0]);
 198       for (i = 0; i < len - 1; ++i)
 199         {
 200           int next = COMBINING_CLASS (string[i + 1]);
 201           if (next != 0 && last > next)
 202             {
 203               size_t j;
 204               /* Percolate item leftward through string.  */
 205               for (j = i; j > 0; --j)
 206                 {
 207                   long t;
 208                   if (COMBINING_CLASS (string[j]) <= next)
 209                     break;
 210                   t = string[j + 1];
 211                   string[j + 1] = string[j];
 212                   string[j] = t;
 213                   swap = 1;
 214                 }
 215               /* We're re-entering the loop looking at the old
 216                  character again.  */
 217               next = last;
 218             }
 219           last = next;
 220         }
 221     }
 222 }
 223
 224 static const unsigned char *
 225 find_decomposition (long ch, int compat)
 226 {
 227   int start = 0;
 228   int end = sizeof (decomp_table) / sizeof ((decomp_table)[0]);
 229
 230   if (ch >= decomp_table[start].ch && ch <= decomp_table[end - 1].ch)
 231     {
 232       while (1)
 233         {
 234           int half = (start + end) / 2;
 235           if (ch == decomp_table[half].ch)
 236             {
 237               int offset;
 238
 239               if (compat)
 240                 {
 241                   offset = decomp_table[half].compat_offset;
 242                   if (offset == 0xff)
 243                     offset = decomp_table[half].canon_offset;
 244                 }
 245               else
 246                 {
 247                   offset = decomp_table[half].canon_offset;
 248                   if (offset == 0xff)
 249                     return NULL;
 250                 }
 251
 252               return
 253                 &(decomp_expansion_string
 254                   [decomp_table[half].expansion_offset + offset]);
 255             }
 256           else if (half == start)
 257             break;
 258           else if (ch > decomp_table[half].ch)
 259             start = half;
 260           else
 261             end = half;
 262         }
 263     }
 264
 265   return NULL;
 266 }
 267
 268 #define CI(Page, Char) \
 269   ((compose_table[Page] >= G_UNICODE_MAX_TABLE_INDEX) \
 270    ? (compose_table[Page] - G_UNICODE_MAX_TABLE_INDEX) \
 271    : (compose_data[compose_table[Page]][Char]))
 272
 273 #define COMPOSE_INDEX(Char) \
 274      (((Char) > (G_UNICODE_LAST_CHAR)) ? 0 : CI((Char) >> 8, (Char) & 0xff))
 275
 276 static int
 277 combine (long a, long b, long *result)
 278 {
 279   int index_a, index_b;
 280
 281   index_a = COMPOSE_INDEX (a);
 282   if (index_a >= COMPOSE_FIRST_SINGLE_START && index_a < COMPOSE_SECOND_START)
 283     {
 284       if (b == compose_first_single[index_a - COMPOSE_FIRST_SINGLE_START][0])
 285         {
 286           *result =
 287             compose_first_single[index_a - COMPOSE_FIRST_SINGLE_START][1];
 288           return 1;
 289         }
 290       else
 291         return 0;
 292     }
 293
 294   index_b = COMPOSE_INDEX (b);
 295   if (index_b >= COMPOSE_SECOND_SINGLE_START)
 296     {
 297       if (a ==
 298           compose_second_single[index_b - COMPOSE_SECOND_SINGLE_START][0])
 299         {
 300           *result =
 301             compose_second_single[index_b - COMPOSE_SECOND_SINGLE_START][1];
 302           return 1;
 303         }
 304       else
 305         return 0;
 306     }
 307
 308   if (index_a >= COMPOSE_FIRST_START && index_a < COMPOSE_FIRST_SINGLE_START
 309       && index_b >= COMPOSE_SECOND_START
 310       && index_a < COMPOSE_SECOND_SINGLE_START)
 311     {
 312       long res =
 313         compose_array[index_a - COMPOSE_FIRST_START][index_b -
 314                                                      COMPOSE_SECOND_START];
 315
 316       if (res)
 317         {
 318           *result = res;
 319           return 1;
 320         }
 321     }
 322
 323   return 0;
 324 }
 325
 326 static long *
 327 _g_utf8_normalize_wc (const char *str, int max_len, GNormalizeMode mode)
 328 {
 329   size_t n_wc;
 330   long *wc_buffer;
 331   const char *p;
 332   size_t last_start;
 333   int do_compat = (mode == G_NORMALIZE_NFKC || mode == G_NORMALIZE_NFKD);
 334   int do_compose = (mode == G_NORMALIZE_NFC || mode == G_NORMALIZE_NFKC);
 335
 336   n_wc = 0;
 337   p = str;
 338   while ((max_len < 0 || p < str + max_len) && *p)
 339     {
 340       long wc = stringprep_utf8_to_unichar (p);
 341
 342       const unsigned char *decomp = find_decomposition (wc, do_compat);
 343
 344       if (decomp)
 345         {
 346           int len;
 347           /* We store as a double-nul terminated string.  */
 348           for (len = 0; (decomp[len] || decomp[len + 1]); len += 2)
 349             ;
 350           n_wc += len / 2;
 351         }
 352       else
 353         n_wc++;
 354
 355       p = g_utf8_next_char (p);
 356     }
 357
 358   wc_buffer = malloc (sizeof (long) * (n_wc + 1));
 359
 360   last_start = 0;
 361   n_wc = 0;
 362   p = str;
 363   while ((max_len < 0 || p < str + max_len) && *p)
 364     {
 365       long wc = stringprep_utf8_to_unichar (p);
 366       const unsigned char *decomp;
 367       int cc;
 368       size_t old_n_wc = n_wc;
 369
 370       decomp = find_decomposition (wc, do_compat);
 371
 372       if (decomp)
 373         {
 374           int len;
 375           /* We store as a double-nul terminated string.  */
 376           for (len = 0; (decomp[len] || decomp[len + 1]); len += 2)
 377             wc_buffer[n_wc++] = (decomp[len] << 8 | decomp[len + 1]);
 378         }
 379       else
 380         wc_buffer[n_wc++] = wc;
 381
 382       if (n_wc > 0)
 383         {
 384           cc = COMBINING_CLASS (wc_buffer[old_n_wc]);
 385
 386           if (cc == 0)
 387             {
 388               g_unicode_canonical_ordering (wc_buffer + last_start,
 389                                             n_wc - last_start);
 390               last_start = old_n_wc;
 391             }
 392         }
 393
 394       p = g_utf8_next_char (p);
 395     }
 396
 397   if (n_wc > 0)
 398     {
 399       g_unicode_canonical_ordering (wc_buffer + last_start,
 400                                     n_wc - last_start);
 401       last_start = n_wc;
 402     }
 403
 404   wc_buffer[n_wc] = 0;
 405
 406   /* All decomposed and reordered */
 407
 408
 409   if (do_compose && n_wc > 0)
 410     {
 411       size_t i, j;
 412       int last_cc = 0;
 413       last_start = 0;
 414
 415       for (i = 0; i < n_wc; i++)
 416         {
 417           int cc = COMBINING_CLASS (wc_buffer[i]);
 418
 419           if (i > 0 &&
 420               (last_cc == 0 || last_cc != cc) &&
 421               combine (wc_buffer[last_start], wc_buffer[i],
 422                        &wc_buffer[last_start]))
 423             {
 424               for (j = i + 1; j < n_wc; j++)
 425                 wc_buffer[j - 1] = wc_buffer[j];
 426               n_wc--;
 427               i--;
 428
 429               if (i == last_start)
 430                 last_cc = 0;
 431               else
 432                 last_cc = COMBINING_CLASS (wc_buffer[i - 1]);
 433
 434               continue;
 435             }
 436
 437           if (cc == 0)
 438             last_start = i;
 439
 440           last_cc = cc;
 441         }
 442     }
 443
 444   wc_buffer[n_wc] = 0;
 445
 446   return wc_buffer;
 447 }
 448
 449 /**
 450  * g_unichar_to_utf8:
 451  * @c: a ISO10646 character code
 452  * @outbuf: output buffer, must have at least 6 bytes of space.
 453  *       If %NULL, the length will be computed and returned
 454  *       and nothing will be written to @outbuf.
 455  *
 456  * Converts a single character to UTF-8.
 457  *
 458  * Return value: number of bytes written
 459  **/
 460 int
 461 stringprep_unichar_to_utf8 (long c, char *outbuf)
 462 {
 463   int len = 0;
 464   int first;
 465   int i;
 466
 467   if (c < 0x80)
 468     {
 469       first = 0;
 470       len = 1;
 471     }
 472   else if (c < 0x800)
 473     {
 474       first = 0xc0;
 475       len = 2;
 476     }
 477   else if (c < 0x10000)
 478     {
 479       first = 0xe0;
 480       len = 3;
 481     }
 482   else if (c < 0x200000)
 483     {
 484       first = 0xf0;
 485       len = 4;
 486     }
 487   else if (c < 0x4000000)
 488     {
 489       first = 0xf8;
 490       len = 5;
 491     }
 492   else
 493     {
 494       first = 0xfc;
 495       len = 6;
 496     }
 497
 498   if (outbuf)
 499     {
 500       for (i = len - 1; i > 0; --i)
 501         {
 502           outbuf[i] = (c & 0x3f) | 0x80;
 503           c >>= 6;
 504         }
 505       outbuf[0] = c | first;
 506     }
 507
 508   return len;
 509 }
 510
 511 /**
 512  * stringgprep_utf8_to_ucs4:
 513  * @str: a UTF-8 encoded string
 514  * @len: the maximum length of @str to use. If @len < 0, then
 515  *       the string is nul-terminated.
 516  * @items_written: location to store the number of characters in the
 517  *                 result, or %NULL.
 518  *
 519  * Convert a string from UTF-8 to a 32-bit fixed width
 520  * representation as UCS-4, assuming valid UTF-8 input.
 521  * This function does no error checking on the input.
 522  *
 523  * Return value: a pointer to a newly allocated UCS-4 string.
 524  *               This value must be freed with g_free().
 525  **/
 526 long *
 527 stringprep_utf8_to_ucs4 (const char *str, int len, int *items_written)
 528 {
 529   int j, charlen;
 530   long *result;
 531   int n_chars, i;
 532   const char *p;
 533
 534   p = str;
 535   n_chars = 0;
 536   if (len < 0)
 537     {
 538       while (*p)
 539         {
 540           p = g_utf8_next_char (p);
 541           ++n_chars;
 542         }
 543     }
 544   else
 545     {
 546       while (p < str + len && *p)
 547         {
 548           p = g_utf8_next_char (p);
 549           ++n_chars;
 550         }
 551     }
 552
 553   result = malloc (sizeof (long) * (n_chars + 1));
 554
 555   p = str;
 556   for (i = 0; i < n_chars; i++)
 557     {
 558       long wc = ((unsigned char *) p)[0];
 559
 560       if (wc < 0x80)
 561         {
 562           result[i] = wc;
 563           p++;
 564         }
 565       else
 566         {
 567           if (wc < 0xe0)
 568             {
 569               charlen = 2;
 570               wc &= 0x1f;
 571             }
 572           else if (wc < 0xf0)
 573             {
 574               charlen = 3;
 575               wc &= 0x0f;
 576             }
 577           else if (wc < 0xf8)
 578             {
 579               charlen = 4;
 580               wc &= 0x07;
 581             }
 582           else if (wc < 0xfc)
 583             {
 584               charlen = 5;
 585               wc &= 0x03;
 586             }
 587           else
 588             {
 589               charlen = 6;
 590               wc &= 0x01;
 591             }
 592
 593           for (j = 1; j < charlen; j++)
 594             {
 595               wc <<= 6;
 596               wc |= ((unsigned char *) p)[j] & 0x3f;
 597             }
 598
 599           result[i] = wc;
 600           p += charlen;
 601         }
 602     }
 603   result[i] = 0;
 604
 605   if (items_written)
 606     *items_written = i;
 607
 608   return result;
 609 }
 610
 611 /* This one is kept around for binary backwards compatibility with
 612    library version CURRENT=1. */
 613 long *
 614 stringprep_utf8_to_ucs4_fast (const char *str, int len, int *items_written)
 615 {
 616   return stringprep_utf8_to_ucs4 (str, len, items_written);
 617
 618 }
 619
 620 /**
 621  * g_ucs4_to_utf8:
 622  * @str: a UCS-4 encoded string
 623  * @len: the maximum length of @str to use. If @len < 0, then
 624  *       the string is terminated with a 0 character.
 625  * @items_read: location to store number of characters read read, or %NULL.
 626  * @items_written: location to store number of bytes written or %NULL.
 627  *                 The value here stored does not include the trailing 0
 628  *                 byte.
 629  * @error: location to store the error occuring, or %NULL to ignore
 630  *         errors. Any of the errors in #GConvertError other than
 631  *         %G_CONVERT_ERROR_NO_CONVERSION may occur.
 632  *
 633  * Convert a string from a 32-bit fixed width representation as UCS-4.
 634  * to UTF-8. The result will be terminated with a 0 byte.
 635  *
 636  * Return value: a pointer to a newly allocated UTF-8 string.
 637  *               This value must be freed with g_free(). If an
 638  *               error occurs, %NULL will be returned and
 639  *               @error set.
 640  **/
 641 char *
 642 stringprep_ucs4_to_utf8 (const long *str,
 643                          int len, int *items_read, int *items_written)
 644 {
 645   int result_length;
 646   char *result = NULL;
 647   char *p;
 648   int i;
 649
 650   result_length = 0;
 651   for (i = 0; len < 0 || i < len; i++)
 652     {
 653       if (!str[i])
 654         break;
 655
 656       if (str[i] >= 0x80000000)
 657         {
 658           if (items_read)
 659             *items_read = i;
 660
 661           goto err_out;
 662         }
 663
 664       result_length += UTF8_LENGTH (str[i]);
 665     }
 666
 667   result = malloc (result_length + 1);
 668   p = result;
 669
 670   i = 0;
 671   while (p < result + result_length)
 672     p += stringprep_unichar_to_utf8 (str[i++], p);
 673
 674   *p = '\0';
 675
 676   if (items_written)
 677     *items_written = p - result;
 678
 679 err_out:
 680   if (items_read)
 681     *items_read = i;
 682
 683   return result;
 684 }
 685
 686 /**
 687  * g_utf8_normalize:
 688  * @str: a UTF-8 encoded string.
 689  * @len: length of @str, in bytes, or -1 if @str is nul-terminated.
 690  * @mode: the type of normalization to perform.
 691  *
 692  * Converts a string into canonical form, standardizing
 693  * such issues as whether a character with an accent
 694  * is represented as a base character and combining
 695  * accent or as a single precomposed character. You
 696  * should generally call g_utf8_normalize() before
 697  * comparing two Unicode strings.
 698  *
 699  * The normalization mode %G_NORMALIZE_DEFAULT only
 700  * standardizes differences that do not affect the
 701  * text content, such as the above-mentioned accent
 702  * representation. %G_NORMALIZE_ALL also standardizes
 703  * the "compatibility" characters in Unicode, such
 704  * as SUPERSCRIPT THREE to the standard forms
 705  * (in this case DIGIT THREE). Formatting information
 706  * may be lost but for most text operations such
 707  * characters should be considered the same.
 708  * For example, g_utf8_collate() normalizes
 709  * with %G_NORMALIZE_ALL as its first step.
 710  *
 711  * %G_NORMALIZE_DEFAULT_COMPOSE and %G_NORMALIZE_ALL_COMPOSE
 712  * are like %G_NORMALIZE_DEFAULT and %G_NORMALIZE_ALL,
 713  * but returned a result with composed forms rather
 714  * than a maximally decomposed form. This is often
 715  * useful if you intend to convert the string to
 716  * a legacy encoding or pass it to a system with
 717  * less capable Unicode handling.
 718  *
 719  * Return value: a newly allocated string, that is the
 720  *   normalized form of @str.
 721  **/
 722 static char *
 723 g_utf8_normalize (const char *str, int len, GNormalizeMode mode)
 724 {
 725   long *result_wc = _g_utf8_normalize_wc (str, len, mode);
 726   char *result;
 727
 728   result = stringprep_ucs4_to_utf8 (result_wc, -1, NULL, NULL);
 729   free (result_wc);
 730
 731   return result;
 732 }
 733
 734 char *
 735 stringprep_utf8_nfkc_normalize (const char *str, int len)
 736 {
 737   return g_utf8_normalize (str, len, G_NORMALIZE_NFKC);
 738 }
 739
 740 long *
 741 stringprep_ucs4_nfkc_normalize (long *str, int len)
 742 {
 743   char *p;
 744   long *result_wc;
 745
 746   p = stringprep_ucs4_to_utf8 (str, len, 0, 0);
 747   result_wc = _g_utf8_normalize_wc (p, -1, G_NORMALIZE_NFKC);
 748   free (p);
 749
 750   return result_wc;
 751 }