LCOV - code coverage report
Current view: top level - lib - nfkc.c (source / functions) Hit Total Coverage
Test: GNU Libidn Lines: 244 281 86.8 %
Date: 2014-08-10 Functions: 16 18 88.9 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 216 302 71.5 %

           Branch data     Line data    Source code
       1                 :            : /* nfkc.c --- Unicode normalization utilities.
       2                 :            :    Copyright (C) 2002-2014 Simon Josefsson
       3                 :            : 
       4                 :            :    This file is part of GNU Libidn.
       5                 :            : 
       6                 :            :    GNU Libidn is free software: you can redistribute it and/or
       7                 :            :    modify it under the terms of either:
       8                 :            : 
       9                 :            :      * the GNU Lesser General Public License as published by the Free
      10                 :            :        Software Foundation; either version 3 of the License, or (at
      11                 :            :        your option) any later version.
      12                 :            : 
      13                 :            :    or
      14                 :            : 
      15                 :            :      * the GNU General Public License as published by the Free
      16                 :            :        Software Foundation; either version 2 of the License, or (at
      17                 :            :        your option) any later version.
      18                 :            : 
      19                 :            :    or both in parallel, as here.
      20                 :            : 
      21                 :            :    GNU Libidn is distributed in the hope that it will be useful,
      22                 :            :    but WITHOUT ANY WARRANTY; without even the implied warranty of
      23                 :            :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      24                 :            :    General Public License for more details.
      25                 :            : 
      26                 :            :    You should have received copies of the GNU General Public License and
      27                 :            :    the GNU Lesser General Public License along with this program.  If
      28                 :            :    not, see <http://www.gnu.org/licenses/>. */
      29                 :            : 
      30                 :            : #ifdef HAVE_CONFIG_H
      31                 :            : #include "config.h"
      32                 :            : #endif
      33                 :            : 
      34                 :            : #include <stdlib.h>
      35                 :            : #include <string.h>
      36                 :            : 
      37                 :            : #include "stringprep.h"
      38                 :            : 
      39                 :            : /* Hacks to make syncing with GLIB code easier. */
      40                 :            : #define gboolean int
      41                 :            : #define gchar char
      42                 :            : #define guchar unsigned char
      43                 :            : #define glong long
      44                 :            : #define gint int
      45                 :            : #define guint unsigned int
      46                 :            : #define gushort unsigned short
      47                 :            : #define gint16 int16_t
      48                 :            : #define guint16 uint16_t
      49                 :            : #define gunichar uint32_t
      50                 :            : #define gsize size_t
      51                 :            : #define gssize ssize_t
      52                 :            : #define g_malloc malloc
      53                 :            : #define g_free free
      54                 :            : #define g_return_val_if_fail(expr,val)  {               \
      55                 :            :     if (!(expr))                                        \
      56                 :            :       return (val);                                     \
      57                 :            :   }
      58                 :            : 
      59                 :            : /* Code from GLIB gmacros.h starts here. */
      60                 :            : 
      61                 :            : /* GLIB - Library of useful routines for C programming
      62                 :            :  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
      63                 :            :  *
      64                 :            :  * This library is free software; you can redistribute it and/or
      65                 :            :  * modify it under the terms of the GNU Lesser General Public
      66                 :            :  * License as published by the Free Software Foundation; either
      67                 :            :  * version 2 of the License, or (at your option) any later version.
      68                 :            :  *
      69                 :            :  * This library is distributed in the hope that it will be useful,
      70                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      71                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      72                 :            :  * Lesser General Public License for more details.
      73                 :            :  *
      74                 :            :  * You should have received a copy of the GNU Lesser General Public
      75                 :            :  * License along with this library; if not, write to the
      76                 :            :  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
      77                 :            :  * Boston, MA 02111-1307, USA.
      78                 :            :  */
      79                 :            : 
      80                 :            : #ifndef FALSE
      81                 :            : #define FALSE   (0)
      82                 :            : #endif
      83                 :            : 
      84                 :            : #ifndef TRUE
      85                 :            : #define TRUE    (!FALSE)
      86                 :            : #endif
      87                 :            : 
      88                 :            : #define G_N_ELEMENTS(arr)               (sizeof (arr) / sizeof ((arr)[0]))
      89                 :            : 
      90                 :            : #define G_UNLIKELY(expr) (expr)
      91                 :            : 
      92                 :            : /* Code from GLIB gunicode.h starts here. */
      93                 :            : 
      94                 :            : /* gunicode.h - Unicode manipulation functions
      95                 :            :  *
      96                 :            :  *  Copyright (C) 1999, 2000 Tom Tromey
      97                 :            :  *  Copyright 2000, 2005 Red Hat, Inc.
      98                 :            :  *
      99                 :            :  * The Gnome Library is free software; you can redistribute it and/or
     100                 :            :  * modify it under the terms of the GNU Lesser General Public License as
     101                 :            :  * published by the Free Software Foundation; either version 2 of the
     102                 :            :  * License, or (at your option) any later version.
     103                 :            :  *
     104                 :            :  * The Gnome Library is distributed in the hope that it will be useful,
     105                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     106                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     107                 :            :  * Lesser General Public License for more details.
     108                 :            :  *
     109                 :            :  * You should have received a copy of the GNU Lesser General Public
     110                 :            :  * License along with the Gnome Library; see the file COPYING.LIB.  If not,
     111                 :            :  * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     112                 :            :  *   Boston, MA 02111-1307, USA.
     113                 :            :  */
     114                 :            : 
     115                 :            : typedef enum
     116                 :            : {
     117                 :            :   G_NORMALIZE_DEFAULT,
     118                 :            :   G_NORMALIZE_NFD = G_NORMALIZE_DEFAULT,
     119                 :            :   G_NORMALIZE_DEFAULT_COMPOSE,
     120                 :            :   G_NORMALIZE_NFC = G_NORMALIZE_DEFAULT_COMPOSE,
     121                 :            :   G_NORMALIZE_ALL,
     122                 :            :   G_NORMALIZE_NFKD = G_NORMALIZE_ALL,
     123                 :            :   G_NORMALIZE_ALL_COMPOSE,
     124                 :            :   G_NORMALIZE_NFKC = G_NORMALIZE_ALL_COMPOSE
     125                 :            : }
     126                 :            : GNormalizeMode;
     127                 :            : 
     128                 :            : #define g_utf8_next_char(p) ((p) + g_utf8_skip[*(const guchar *)(p)])
     129                 :            : 
     130                 :            : /* Code from GLIB gutf8.c starts here. */
     131                 :            : 
     132                 :            : /* gutf8.c - Operations on UTF-8 strings.
     133                 :            :  *
     134                 :            :  * Copyright (C) 1999 Tom Tromey
     135                 :            :  * Copyright (C) 2000 Red Hat, Inc.
     136                 :            :  *
     137                 :            :  * This library is free software; you can redistribute it and/or
     138                 :            :  * modify it under the terms of the GNU Lesser General Public
     139                 :            :  * License as published by the Free Software Foundation; either
     140                 :            :  * version 2 of the License, or (at your option) any later version.
     141                 :            :  *
     142                 :            :  * This library is distributed in the hope that it will be useful,
     143                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     144                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     145                 :            :  * Lesser General Public License for more details.
     146                 :            :  *
     147                 :            :  * You should have received a copy of the GNU Lesser General Public
     148                 :            :  * License along with this library; if not, write to the
     149                 :            :  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     150                 :            :  * Boston, MA 02111-1307, USA.
     151                 :            :  */
     152                 :            : 
     153                 :            : #define UTF8_COMPUTE(Char, Mask, Len)           \
     154                 :            :   if (Char < 128)                            \
     155                 :            :     {                                           \
     156                 :            :       Len = 1;                                  \
     157                 :            :       Mask = 0x7f;                              \
     158                 :            :     }                                           \
     159                 :            :   else if ((Char & 0xe0) == 0xc0)           \
     160                 :            :     {                                           \
     161                 :            :       Len = 2;                                  \
     162                 :            :       Mask = 0x1f;                              \
     163                 :            :     }                                           \
     164                 :            :   else if ((Char & 0xf0) == 0xe0)           \
     165                 :            :     {                                           \
     166                 :            :       Len = 3;                                  \
     167                 :            :       Mask = 0x0f;                              \
     168                 :            :     }                                           \
     169                 :            :   else if ((Char & 0xf8) == 0xf0)           \
     170                 :            :     {                                           \
     171                 :            :       Len = 4;                                  \
     172                 :            :       Mask = 0x07;                              \
     173                 :            :     }                                           \
     174                 :            :   else if ((Char & 0xfc) == 0xf8)           \
     175                 :            :     {                                           \
     176                 :            :       Len = 5;                                  \
     177                 :            :       Mask = 0x03;                              \
     178                 :            :     }                                           \
     179                 :            :   else if ((Char & 0xfe) == 0xfc)           \
     180                 :            :     {                                           \
     181                 :            :       Len = 6;                                  \
     182                 :            :       Mask = 0x01;                              \
     183                 :            :     }                                           \
     184                 :            :   else                                          \
     185                 :            :     Len = -1;
     186                 :            : 
     187                 :            : #define UTF8_LENGTH(Char)                       \
     188                 :            :   ((Char) < 0x80 ? 1 :                               \
     189                 :            :    ((Char) < 0x800 ? 2 :                     \
     190                 :            :     ((Char) < 0x10000 ? 3 :                  \
     191                 :            :      ((Char) < 0x200000 ? 4 :                        \
     192                 :            :       ((Char) < 0x4000000 ? 5 : 6)))))
     193                 :            : 
     194                 :            : #define UTF8_GET(Result, Chars, Count, Mask, Len)                             \
     195                 :            :   (Result) = (Chars)[0] & (Mask);                                         \
     196                 :            :   for ((Count) = 1; (Count) < (Len); ++(Count))                                    \
     197                 :            :     {                                                                         \
     198                 :            :       if (((Chars)[(Count)] & 0xc0) != 0x80)                                      \
     199                 :            :         {                                                                     \
     200                 :            :           (Result) = -1;                                                      \
     201                 :            :           break;                                                              \
     202                 :            :         }                                                                     \
     203                 :            :       (Result) <<= 6;                                                           \
     204                 :            :       (Result) |= ((Chars)[(Count)] & 0x3f);                                      \
     205                 :            :     }
     206                 :            : 
     207                 :            : static const gchar utf8_skip_data[256] = {
     208                 :            :   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,
     209                 :            :   1, 1, 1, 1, 1, 1, 1,
     210                 :            :   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,
     211                 :            :   1, 1, 1, 1, 1, 1, 1,
     212                 :            :   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,
     213                 :            :   1, 1, 1, 1, 1, 1, 1,
     214                 :            :   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,
     215                 :            :   1, 1, 1, 1, 1, 1, 1,
     216                 :            :   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,
     217                 :            :   1, 1, 1, 1, 1, 1, 1,
     218                 :            :   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,
     219                 :            :   1, 1, 1, 1, 1, 1, 1,
     220                 :            :   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,
     221                 :            :   2, 2, 2, 2, 2, 2, 2,
     222                 :            :   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,
     223                 :            :   5, 5, 5, 6, 6, 1, 1
     224                 :            : };
     225                 :            : 
     226                 :            : static const gchar *const g_utf8_skip = utf8_skip_data;
     227                 :            : 
     228                 :            : /*
     229                 :            :  * g_utf8_strlen:
     230                 :            :  * @p: pointer to the start of a UTF-8 encoded string
     231                 :            :  * @max: the maximum number of bytes to examine. If @max
     232                 :            :  *       is less than 0, then the string is assumed to be
     233                 :            :  *       nul-terminated. If @max is 0, @p will not be examined and
     234                 :            :  *       may be %NULL.
     235                 :            :  *
     236                 :            :  * Computes the length of the string in characters, not including
     237                 :            :  * the terminating nul character.
     238                 :            :  *
     239                 :            :  * Return value: the length of the string in characters
     240                 :            :  **/
     241                 :            : static glong
     242                 :        156 : g_utf8_strlen (const gchar * p, gssize max)
     243                 :            : {
     244                 :        156 :   glong len = 0;
     245                 :        156 :   const gchar *start = p;
     246 [ -  + ][ #  # ]:        156 :   g_return_val_if_fail (p != NULL || max == 0, 0);
     247                 :            : 
     248         [ +  - ]:        156 :   if (max < 0)
     249                 :            :     {
     250         [ +  + ]:        470 :       while (*p)
     251                 :            :         {
     252                 :        314 :           p = g_utf8_next_char (p);
     253                 :        314 :           ++len;
     254                 :            :         }
     255                 :            :     }
     256                 :            :   else
     257                 :            :     {
     258 [ #  # ][ #  # ]:          0 :       if (max == 0 || !*p)
     259                 :          0 :         return 0;
     260                 :            : 
     261                 :          0 :       p = g_utf8_next_char (p);
     262                 :            : 
     263 [ #  # ][ #  # ]:          0 :       while (p - start < max && *p)
     264                 :            :         {
     265                 :          0 :           ++len;
     266                 :          0 :           p = g_utf8_next_char (p);
     267                 :            :         }
     268                 :            : 
     269                 :            :       /* only do the last len increment if we got a complete
     270                 :            :        * char (don't count partial chars)
     271                 :            :        */
     272         [ #  # ]:          0 :       if (p - start <= max)
     273                 :          0 :         ++len;
     274                 :            :     }
     275                 :            : 
     276                 :        156 :   return len;
     277                 :            : }
     278                 :            : 
     279                 :            : /*
     280                 :            :  * g_utf8_get_char:
     281                 :            :  * @p: a pointer to Unicode character encoded as UTF-8
     282                 :            :  *
     283                 :            :  * Converts a sequence of bytes encoded as UTF-8 to a Unicode character.
     284                 :            :  * If @p does not point to a valid UTF-8 encoded character, results are
     285                 :            :  * undefined. If you are not sure that the bytes are complete
     286                 :            :  * valid Unicode characters, you should use g_utf8_get_char_validated()
     287                 :            :  * instead.
     288                 :            :  *
     289                 :            :  * Return value: the resulting character
     290                 :            :  **/
     291                 :            : static gunichar
     292                 :       3534 : g_utf8_get_char (const gchar * p)
     293                 :            : {
     294                 :       3534 :   int i, mask = 0, len;
     295                 :            :   gunichar result;
     296                 :       3534 :   unsigned char c = (unsigned char) *p;
     297                 :            : 
     298 [ +  + ][ +  + ]:       3534 :   UTF8_COMPUTE (c, mask, len);
         [ +  + ][ +  - ]
         [ #  # ][ #  # ]
     299         [ -  + ]:       3534 :   if (len == -1)
     300                 :          0 :     return (gunichar) - 1;
     301 [ -  + ][ +  + ]:       6430 :   UTF8_GET (result, p, i, mask, len);
     302                 :            : 
     303                 :       3534 :   return result;
     304                 :            : }
     305                 :            : 
     306                 :            : /*
     307                 :            :  * g_unichar_to_utf8:
     308                 :            :  * @c: a Unicode character code
     309                 :            :  * @outbuf: output buffer, must have at least 6 bytes of space.
     310                 :            :  *       If %NULL, the length will be computed and returned
     311                 :            :  *       and nothing will be written to @outbuf.
     312                 :            :  *
     313                 :            :  * Converts a single character to UTF-8.
     314                 :            :  *
     315                 :            :  * Return value: number of bytes written
     316                 :            :  **/
     317                 :            : static int
     318                 :       5693 : g_unichar_to_utf8 (gunichar c, gchar * outbuf)
     319                 :            : {
     320                 :            :   /* If this gets modified, also update the copy in g_string_insert_unichar() */
     321                 :       5693 :   guint len = 0;
     322                 :            :   int first;
     323                 :            :   int i;
     324                 :            : 
     325         [ +  + ]:       5693 :   if (c < 0x80)
     326                 :            :     {
     327                 :       3070 :       first = 0;
     328                 :       3070 :       len = 1;
     329                 :            :     }
     330         [ +  + ]:       2623 :   else if (c < 0x800)
     331                 :            :     {
     332                 :       1351 :       first = 0xc0;
     333                 :       1351 :       len = 2;
     334                 :            :     }
     335         [ +  + ]:       1272 :   else if (c < 0x10000)
     336                 :            :     {
     337                 :       1233 :       first = 0xe0;
     338                 :       1233 :       len = 3;
     339                 :            :     }
     340         [ +  - ]:         39 :   else if (c < 0x200000)
     341                 :            :     {
     342                 :         39 :       first = 0xf0;
     343                 :         39 :       len = 4;
     344                 :            :     }
     345         [ #  # ]:          0 :   else if (c < 0x4000000)
     346                 :            :     {
     347                 :          0 :       first = 0xf8;
     348                 :          0 :       len = 5;
     349                 :            :     }
     350                 :            :   else
     351                 :            :     {
     352                 :          0 :       first = 0xfc;
     353                 :          0 :       len = 6;
     354                 :            :     }
     355                 :            : 
     356         [ +  - ]:       5693 :   if (outbuf)
     357                 :            :     {
     358         [ +  + ]:       9627 :       for (i = len - 1; i > 0; --i)
     359                 :            :         {
     360                 :       3934 :           outbuf[i] = (c & 0x3f) | 0x80;
     361                 :       3934 :           c >>= 6;
     362                 :            :         }
     363                 :       5693 :       outbuf[0] = c | first;
     364                 :            :     }
     365                 :            : 
     366                 :       5693 :   return len;
     367                 :            : }
     368                 :            : 
     369                 :            : /*
     370                 :            :  * g_utf8_to_ucs4_fast:
     371                 :            :  * @str: a UTF-8 encoded string
     372                 :            :  * @len: the maximum length of @str to use, in bytes. If @len < 0,
     373                 :            :  *       then the string is nul-terminated.
     374                 :            :  * @items_written: location to store the number of characters in the
     375                 :            :  *                 result, or %NULL.
     376                 :            :  *
     377                 :            :  * Convert a string from UTF-8 to a 32-bit fixed width
     378                 :            :  * representation as UCS-4, assuming valid UTF-8 input.
     379                 :            :  * This function is roughly twice as fast as g_utf8_to_ucs4()
     380                 :            :  * but does no error checking on the input. A trailing 0 character
     381                 :            :  * will be added to the string after the converted text.
     382                 :            :  *
     383                 :            :  * Return value: a pointer to a newly allocated UCS-4 string.
     384                 :            :  *               This value must be freed with g_free().
     385                 :            :  **/
     386                 :            : static gunichar *
     387                 :        568 : g_utf8_to_ucs4_fast (const gchar * str, glong len, glong * items_written)
     388                 :            : {
     389                 :            :   gunichar *result;
     390                 :            :   gsize n_chars, i;
     391                 :            :   const gchar *p;
     392                 :            : 
     393         [ -  + ]:        568 :   g_return_val_if_fail (str != NULL, NULL);
     394                 :            : 
     395                 :        568 :   p = str;
     396                 :        568 :   n_chars = 0;
     397         [ +  - ]:        568 :   if (len < 0)
     398                 :            :     {
     399         [ +  + ]:       6009 :       while (*p)
     400                 :            :         {
     401                 :       5441 :           p = g_utf8_next_char (p);
     402                 :       5441 :           ++n_chars;
     403                 :            :         }
     404                 :            :     }
     405                 :            :   else
     406                 :            :     {
     407 [ #  # ][ #  # ]:          0 :       while (p < str + len && *p)
     408                 :            :         {
     409                 :          0 :           p = g_utf8_next_char (p);
     410                 :          0 :           ++n_chars;
     411                 :            :         }
     412                 :            :     }
     413                 :            : 
     414                 :        568 :   result = g_malloc (sizeof (gunichar) * (n_chars + 1));
     415         [ -  + ]:        568 :   if (!result)
     416                 :          0 :     return NULL;
     417                 :            : 
     418                 :        568 :   p = str;
     419         [ +  + ]:       6009 :   for (i = 0; i < n_chars; i++)
     420                 :            :     {
     421                 :       5441 :       gunichar wc = (guchar) * p++;
     422                 :            : 
     423         [ +  + ]:       5441 :       if (wc < 0x80)
     424                 :            :         {
     425                 :       3457 :           result[i] = wc;
     426                 :            :         }
     427                 :            :       else
     428                 :            :         {
     429                 :       1984 :           gunichar mask = 0x40;
     430                 :            : 
     431         [ +  + ]:       1984 :           if (G_UNLIKELY ((wc & mask) == 0))
     432                 :            :             {
     433                 :            :               /* It's an out-of-sequence 10xxxxxxx byte.
     434                 :            :                * Rather than making an ugly hash of this and the next byte
     435                 :            :                * and overrunning the buffer, it's more useful to treat it
     436                 :            :                * with a replacement character */
     437                 :         14 :               result[i] = 0xfffd;
     438                 :         14 :               continue;
     439                 :            :             }
     440                 :            : 
     441                 :            :           do
     442                 :            :             {
     443                 :       3002 :               wc <<= 6;
     444                 :       3002 :               wc |= (guchar) (*p++) & 0x3f;
     445                 :       3002 :               mask <<= 5;
     446                 :            :             }
     447         [ +  + ]:       3002 :           while ((wc & mask) != 0);
     448                 :            : 
     449                 :       1970 :           wc &= mask - 1;
     450                 :            : 
     451                 :       1970 :           result[i] = wc;
     452                 :            :         }
     453                 :            :     }
     454                 :        568 :   result[i] = 0;
     455                 :            : 
     456         [ +  + ]:        568 :   if (items_written)
     457                 :        355 :     *items_written = i;
     458                 :            : 
     459                 :        568 :   return result;
     460                 :            : }
     461                 :            : 
     462                 :            : /*
     463                 :            :  * g_ucs4_to_utf8:
     464                 :            :  * @str: a UCS-4 encoded string
     465                 :            :  * @len: the maximum length (number of characters) of @str to use.
     466                 :            :  *       If @len < 0, then the string is nul-terminated.
     467                 :            :  * @items_read: location to store number of characters read, or %NULL.
     468                 :            :  * @items_written: location to store number of bytes written or %NULL.
     469                 :            :  *                 The value here stored does not include the trailing 0
     470                 :            :  *                 byte.
     471                 :            :  * @error: location to store the error occurring, or %NULL to ignore
     472                 :            :  *         errors. Any of the errors in #GConvertError other than
     473                 :            :  *         %G_CONVERT_ERROR_NO_CONVERSION may occur.
     474                 :            :  *
     475                 :            :  * Convert a string from a 32-bit fixed width representation as UCS-4.
     476                 :            :  * to UTF-8. The result will be terminated with a 0 byte.
     477                 :            :  *
     478                 :            :  * Return value: a pointer to a newly allocated UTF-8 string.
     479                 :            :  *               This value must be freed with g_free(). If an
     480                 :            :  *               error occurs, %NULL will be returned and
     481                 :            :  *               @error set. In that case, @items_read will be
     482                 :            :  *               set to the position of the first invalid input
     483                 :            :  *               character.
     484                 :            :  **/
     485                 :            : static gchar *
     486                 :        665 : g_ucs4_to_utf8 (const gunichar * str,
     487                 :            :                 glong len,
     488                 :            :                 glong * items_read, glong * items_written)
     489                 :            : {
     490                 :            :   gint result_length;
     491                 :        665 :   gchar *result = NULL;
     492                 :            :   gchar *p;
     493                 :            :   gint i;
     494                 :            : 
     495                 :        665 :   result_length = 0;
     496 [ +  + ][ +  + ]:       6358 :   for (i = 0; len < 0 || i < len; i++)
     497                 :            :     {
     498         [ +  + ]:       5774 :       if (!str[i])
     499                 :         81 :         break;
     500                 :            : 
     501         [ -  + ]:       5693 :       if (str[i] >= 0x80000000)
     502                 :          0 :         goto err_out;
     503                 :            : 
     504 [ +  + ][ +  + ]:       5693 :       result_length += UTF8_LENGTH (str[i]);
         [ +  + ][ -  + ]
                 [ #  # ]
     505                 :            :     }
     506                 :            : 
     507                 :        665 :   result = g_malloc (result_length + 1);
     508         [ -  + ]:        665 :   if (!result)
     509                 :          0 :     return NULL;
     510                 :        665 :   p = result;
     511                 :            : 
     512                 :        665 :   i = 0;
     513         [ +  + ]:       6358 :   while (p < result + result_length)
     514                 :       5693 :     p += g_unichar_to_utf8 (str[i++], p);
     515                 :            : 
     516                 :        665 :   *p = '\0';
     517                 :            : 
     518         [ +  + ]:        665 :   if (items_written)
     519                 :          9 :     *items_written = p - result;
     520                 :            : 
     521                 :            : err_out:
     522         [ +  + ]:        665 :   if (items_read)
     523                 :          9 :     *items_read = i;
     524                 :            : 
     525                 :        665 :   return result;
     526                 :            : }
     527                 :            : 
     528                 :            : /* Code from GLIB gunidecomp.c starts here. */
     529                 :            : 
     530                 :            : /* decomp.c - Character decomposition.
     531                 :            :  *
     532                 :            :  *  Copyright (C) 1999, 2000 Tom Tromey
     533                 :            :  *  Copyright 2000 Red Hat, Inc.
     534                 :            :  *
     535                 :            :  * The Gnome Library is free software; you can redistribute it and/or
     536                 :            :  * modify it under the terms of the GNU Lesser General Public License as
     537                 :            :  * published by the Free Software Foundation; either version 2 of the
     538                 :            :  * License, or (at your option) any later version.
     539                 :            :  *
     540                 :            :  * The Gnome Library is distributed in the hope that it will be useful,
     541                 :            :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     542                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     543                 :            :  * Lesser General Public License for more details.
     544                 :            :  *
     545                 :            :  * You should have received a copy of the GNU Lesser General Public
     546                 :            :  * License along with the Gnome Library; see the file COPYING.LIB.  If not,
     547                 :            :  * write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     548                 :            :  *   Boston, MA 02111-1307, USA.
     549                 :            :  */
     550                 :            : 
     551                 :            : #include "gunidecomp.h"
     552                 :            : #include "gunicomp.h"
     553                 :            : 
     554                 :            : #define CC_PART1(Page, Char)                                            \
     555                 :            :   ((combining_class_table_part1[Page] >= G_UNICODE_MAX_TABLE_INDEX)  \
     556                 :            :    ? (combining_class_table_part1[Page] - G_UNICODE_MAX_TABLE_INDEX)    \
     557                 :            :    : (cclass_data[combining_class_table_part1[Page]][Char]))
     558                 :            : 
     559                 :            : #define CC_PART2(Page, Char)                                            \
     560                 :            :   ((combining_class_table_part2[Page] >= G_UNICODE_MAX_TABLE_INDEX)  \
     561                 :            :    ? (combining_class_table_part2[Page] - G_UNICODE_MAX_TABLE_INDEX)    \
     562                 :            :    : (cclass_data[combining_class_table_part2[Page]][Char]))
     563                 :            : 
     564                 :            : #define COMBINING_CLASS(Char)                                   \
     565                 :            :   (((Char) <= G_UNICODE_LAST_CHAR_PART1)                     \
     566                 :            :    ? CC_PART1 ((Char) >> 8, (Char) & 0xff)                    \
     567                 :            :    : (((Char) >= 0xe0000 && (Char) <= G_UNICODE_LAST_CHAR)        \
     568                 :            :       ? CC_PART2 (((Char) - 0xe0000) >> 8, (Char) & 0xff)     \
     569                 :            :       : 0))
     570                 :            : 
     571                 :            : /* constants for hangul syllable [de]composition */
     572                 :            : #define SBase 0xAC00
     573                 :            : #define LBase 0x1100
     574                 :            : #define VBase 0x1161
     575                 :            : #define TBase 0x11A7
     576                 :            : #define LCount 19
     577                 :            : #define VCount 21
     578                 :            : #define TCount 28
     579                 :            : #define NCount (VCount * TCount)
     580                 :            : #define SCount (LCount * NCount)
     581                 :            : 
     582                 :            : /*
     583                 :            :  * g_unicode_canonical_ordering:
     584                 :            :  * @string: a UCS-4 encoded string.
     585                 :            :  * @len: the maximum length of @string to use.
     586                 :            :  *
     587                 :            :  * Computes the canonical ordering of a string in-place.
     588                 :            :  * This rearranges decomposed characters in the string
     589                 :            :  * according to their combining classes.  See the Unicode
     590                 :            :  * manual for more information.
     591                 :            :  **/
     592                 :            : static void
     593                 :       1798 : g_unicode_canonical_ordering (gunichar * string, gsize len)
     594                 :            : {
     595                 :            :   gsize i;
     596                 :       1798 :   int swap = 1;
     597                 :            : 
     598         [ +  + ]:       3596 :   while (swap)
     599                 :            :     {
     600                 :            :       int last;
     601                 :       1798 :       swap = 0;
     602 [ +  + ][ +  + ]:       1798 :       last = COMBINING_CLASS (string[0]);
         [ +  + ][ +  - ]
                 [ +  - ]
     603         [ +  + ]:       3650 :       for (i = 0; i < len - 1; ++i)
     604                 :            :         {
     605 [ +  + ][ +  + ]:       1852 :           int next = COMBINING_CLASS (string[i + 1]);
         [ +  - ][ +  - ]
                 [ +  - ]
     606 [ +  + ][ -  + ]:       1852 :           if (next != 0 && last > next)
     607                 :            :             {
     608                 :            :               gsize j;
     609                 :            :               /* Percolate item leftward through string.  */
     610         [ #  # ]:          0 :               for (j = i + 1; j > 0; --j)
     611                 :            :                 {
     612                 :            :                   gunichar t;
     613 [ #  # ][ #  # ]:          0 :                   if (COMBINING_CLASS (string[j - 1]) <= next)
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
     614                 :          0 :                     break;
     615                 :          0 :                   t = string[j];
     616                 :          0 :                   string[j] = string[j - 1];
     617                 :          0 :                   string[j - 1] = t;
     618                 :          0 :                   swap = 1;
     619                 :            :                 }
     620                 :            :               /* We're re-entering the loop looking at the old
     621                 :            :                  character again.  */
     622                 :          0 :               next = last;
     623                 :            :             }
     624                 :       1852 :           last = next;
     625                 :            :         }
     626                 :            :     }
     627                 :       1798 : }
     628                 :            : 
     629                 :            : /* http://www.unicode.org/unicode/reports/tr15/#Hangul
     630                 :            :  * r should be null or have sufficient space. Calling with r == NULL will
     631                 :            :  * only calculate the result_len; however, a buffer with space for three
     632                 :            :  * characters will always be big enough. */
     633                 :            : static void
     634                 :        102 : decompose_hangul (gunichar s, gunichar * r, gsize * result_len)
     635                 :            : {
     636                 :        102 :   gint SIndex = s - SBase;
     637                 :        102 :   gint TIndex = SIndex % TCount;
     638                 :            : 
     639         [ +  + ]:        102 :   if (r)
     640                 :            :     {
     641                 :         51 :       r[0] = LBase + SIndex / NCount;
     642                 :         51 :       r[1] = VBase + (SIndex % NCount) / TCount;
     643                 :            :     }
     644                 :            : 
     645         [ +  + ]:        102 :   if (TIndex)
     646                 :            :     {
     647         [ +  + ]:         50 :       if (r)
     648                 :         25 :         r[2] = TBase + TIndex;
     649                 :         50 :       *result_len = 3;
     650                 :            :     }
     651                 :            :   else
     652                 :         52 :     *result_len = 2;
     653                 :        102 : }
     654                 :            : 
     655                 :            : /* returns a pointer to a null-terminated UTF-8 string */
     656                 :            : static const gchar *
     657                 :       3118 : find_decomposition (gunichar ch, gboolean compat)
     658                 :            : {
     659                 :       3118 :   int start = 0;
     660                 :       3118 :   int end = G_N_ELEMENTS (decomp_table);
     661                 :            : 
     662 [ +  + ][ +  + ]:       3118 :   if (ch >= decomp_table[start].ch && ch <= decomp_table[end - 1].ch)
     663                 :            :     {
     664                 :            :       while (TRUE)
     665                 :            :         {
     666                 :      21168 :           int half = (start + end) / 2;
     667         [ +  + ]:      21168 :           if (ch == decomp_table[half].ch)
     668                 :            :             {
     669                 :            :               int offset;
     670                 :            : 
     671         [ +  - ]:        312 :               if (compat)
     672                 :            :                 {
     673                 :        312 :                   offset = decomp_table[half].compat_offset;
     674         [ +  + ]:        312 :                   if (offset == G_UNICODE_NOT_PRESENT_OFFSET)
     675                 :        244 :                     offset = decomp_table[half].canon_offset;
     676                 :            :                 }
     677                 :            :               else
     678                 :            :                 {
     679                 :          0 :                   offset = decomp_table[half].canon_offset;
     680         [ #  # ]:          0 :                   if (offset == G_UNICODE_NOT_PRESENT_OFFSET)
     681                 :          0 :                     return NULL;
     682                 :            :                 }
     683                 :            : 
     684                 :        312 :               return &(decomp_expansion_string[offset]);
     685                 :            :             }
     686         [ +  + ]:      20856 :           else if (half == start)
     687                 :       1324 :             break;
     688         [ +  + ]:      19532 :           else if (ch > decomp_table[half].ch)
     689                 :       7614 :             start = half;
     690                 :            :           else
     691                 :      11918 :             end = half;
     692                 :      19532 :         }
     693                 :            :     }
     694                 :            : 
     695                 :       3118 :   return NULL;
     696                 :            : }
     697                 :            : 
     698                 :            : /* L,V => LV and LV,T => LVT  */
     699                 :            : static gboolean
     700                 :       1618 : combine_hangul (gunichar a, gunichar b, gunichar * result)
     701                 :            : {
     702                 :       1618 :   gint LIndex = a - LBase;
     703                 :       1618 :   gint SIndex = a - SBase;
     704                 :            : 
     705                 :       1618 :   gint VIndex = b - VBase;
     706                 :       1618 :   gint TIndex = b - TBase;
     707                 :            : 
     708 [ +  + ][ +  + ]:       1618 :   if (0 <= LIndex && LIndex < LCount && 0 <= VIndex && VIndex < VCount)
         [ +  + ][ +  - ]
     709                 :            :     {
     710                 :         53 :       *result = SBase + (LIndex * VCount + VIndex) * TCount;
     711                 :         53 :       return TRUE;
     712                 :            :     }
     713 [ +  + ][ +  + ]:       1565 :   else if (0 <= SIndex && SIndex < SCount && (SIndex % TCount) == 0
                 [ +  + ]
     714 [ +  + ][ +  - ]:         50 :            && 0 < TIndex && TIndex < TCount)
     715                 :            :     {
     716                 :         26 :       *result = a + TIndex;
     717                 :         26 :       return TRUE;
     718                 :            :     }
     719                 :            : 
     720                 :       1618 :   return FALSE;
     721                 :            : }
     722                 :            : 
     723                 :            : #define CI(Page, Char)                                  \
     724                 :            :   ((compose_table[Page] >= G_UNICODE_MAX_TABLE_INDEX)        \
     725                 :            :    ? (compose_table[Page] - G_UNICODE_MAX_TABLE_INDEX)  \
     726                 :            :    : (compose_data[compose_table[Page]][Char]))
     727                 :            : 
     728                 :            : #define COMPOSE_INDEX(Char)                                             \
     729                 :            :   (((Char >> 8) > (COMPOSE_TABLE_LAST)) ? 0 : CI((Char) >> 8, (Char) & 0xff))
     730                 :            : 
     731                 :            : static gboolean
     732                 :       1618 : combine (gunichar a, gunichar b, gunichar * result)
     733                 :            : {
     734                 :            :   gushort index_a, index_b;
     735                 :            : 
     736         [ +  + ]:       1618 :   if (combine_hangul (a, b, result))
     737                 :         79 :     return TRUE;
     738                 :            : 
     739 [ +  + ][ +  + ]:       1539 :   index_a = COMPOSE_INDEX (a);
     740                 :            : 
     741 [ +  + ][ +  - ]:       1539 :   if (index_a >= COMPOSE_FIRST_SINGLE_START && index_a < COMPOSE_SECOND_START)
     742                 :            :     {
     743         [ +  + ]:        117 :       if (b == compose_first_single[index_a - COMPOSE_FIRST_SINGLE_START][0])
     744                 :            :         {
     745                 :         18 :           *result =
     746                 :         18 :             compose_first_single[index_a - COMPOSE_FIRST_SINGLE_START][1];
     747                 :         18 :           return TRUE;
     748                 :            :         }
     749                 :            :       else
     750                 :         99 :         return FALSE;
     751                 :            :     }
     752                 :            : 
     753 [ +  + ][ +  + ]:       1422 :   index_b = COMPOSE_INDEX (b);
     754                 :            : 
     755         [ +  + ]:       1422 :   if (index_b >= COMPOSE_SECOND_SINGLE_START)
     756                 :            :     {
     757         [ +  - ]:          1 :       if (a ==
     758                 :          1 :           compose_second_single[index_b - COMPOSE_SECOND_SINGLE_START][0])
     759                 :            :         {
     760                 :          1 :           *result =
     761                 :          1 :             compose_second_single[index_b - COMPOSE_SECOND_SINGLE_START][1];
     762                 :          1 :           return TRUE;
     763                 :            :         }
     764                 :            :       else
     765                 :          0 :         return FALSE;
     766                 :            :     }
     767                 :            : 
     768 [ +  + ][ +  - ]:       1421 :   if (index_a >= COMPOSE_FIRST_START && index_a < COMPOSE_FIRST_SINGLE_START
     769         [ +  + ]:        785 :       && index_b >= COMPOSE_SECOND_START
     770         [ +  - ]:        144 :       && index_b < COMPOSE_SECOND_SINGLE_START)
     771                 :            :     {
     772                 :        144 :       gunichar res =
     773                 :        144 :         compose_array[index_a - COMPOSE_FIRST_START][index_b -
     774                 :            :                                                      COMPOSE_SECOND_START];
     775                 :            : 
     776         [ +  + ]:        144 :       if (res)
     777                 :            :         {
     778                 :        137 :           *result = res;
     779                 :        137 :           return TRUE;
     780                 :            :         }
     781                 :            :     }
     782                 :            : 
     783                 :       1618 :   return FALSE;
     784                 :            : }
     785                 :            : 
     786                 :            : static gunichar *
     787                 :        228 : _g_utf8_normalize_wc (const gchar * str, gssize max_len, GNormalizeMode mode)
     788                 :            : {
     789                 :            :   gsize n_wc;
     790                 :            :   gunichar *wc_buffer;
     791                 :            :   const char *p;
     792                 :            :   gsize last_start;
     793 [ -  + ][ #  # ]:        228 :   gboolean do_compat = (mode == G_NORMALIZE_NFKC || mode == G_NORMALIZE_NFKD);
     794 [ +  - ][ +  - ]:        228 :   gboolean do_compose = (mode == G_NORMALIZE_NFC || mode == G_NORMALIZE_NFKC);
     795                 :            : 
     796                 :        228 :   n_wc = 0;
     797                 :        228 :   p = str;
     798 [ +  + ][ +  + ]:       1838 :   while ((max_len < 0 || p < str + max_len) && *p)
                 [ +  + ]
     799                 :            :     {
     800                 :            :       const gchar *decomp;
     801                 :       1610 :       gunichar wc = g_utf8_get_char (p);
     802                 :            : 
     803 [ +  + ][ +  + ]:       1610 :       if (wc >= SBase && wc < SBase + SCount)
     804                 :         51 :         {
     805                 :            :           gsize result_len;
     806                 :         51 :           decompose_hangul (wc, NULL, &result_len);
     807                 :         51 :           n_wc += result_len;
     808                 :            :         }
     809                 :            :       else
     810                 :            :         {
     811                 :       1559 :           decomp = find_decomposition (wc, do_compat);
     812                 :            : 
     813         [ +  + ]:       1559 :           if (decomp)
     814                 :        156 :             n_wc += g_utf8_strlen (decomp, -1);
     815                 :            :           else
     816                 :       1403 :             n_wc++;
     817                 :            :         }
     818                 :            : 
     819                 :       1610 :       p = g_utf8_next_char (p);
     820                 :            :     }
     821                 :            : 
     822                 :        228 :   wc_buffer = g_malloc (sizeof (gunichar) * (n_wc + 1));
     823         [ -  + ]:        228 :   if (!wc_buffer)
     824                 :          0 :     return NULL;
     825                 :            : 
     826                 :        228 :   last_start = 0;
     827                 :        228 :   n_wc = 0;
     828                 :        228 :   p = str;
     829 [ +  + ][ +  + ]:       1838 :   while ((max_len < 0 || p < str + max_len) && *p)
                 [ +  + ]
     830                 :            :     {
     831                 :       1610 :       gunichar wc = g_utf8_get_char (p);
     832                 :            :       const gchar *decomp;
     833                 :            :       int cc;
     834                 :       1610 :       gsize old_n_wc = n_wc;
     835                 :            : 
     836 [ +  + ][ +  + ]:       1610 :       if (wc >= SBase && wc < SBase + SCount)
     837                 :         51 :         {
     838                 :            :           gsize result_len;
     839                 :         51 :           decompose_hangul (wc, wc_buffer + n_wc, &result_len);
     840                 :         51 :           n_wc += result_len;
     841                 :            :         }
     842                 :            :       else
     843                 :            :         {
     844                 :       1559 :           decomp = find_decomposition (wc, do_compat);
     845                 :            : 
     846         [ +  + ]:       1559 :           if (decomp)
     847                 :            :             {
     848                 :            :               const char *pd;
     849         [ +  + ]:        470 :               for (pd = decomp; *pd != '\0'; pd = g_utf8_next_char (pd))
     850                 :        314 :                 wc_buffer[n_wc++] = g_utf8_get_char (pd);
     851                 :            :             }
     852                 :            :           else
     853                 :       1403 :             wc_buffer[n_wc++] = wc;
     854                 :            :         }
     855                 :            : 
     856         [ +  - ]:       1610 :       if (n_wc > 0)
     857                 :            :         {
     858 [ +  + ][ +  + ]:       1610 :           cc = COMBINING_CLASS (wc_buffer[old_n_wc]);
         [ +  + ][ +  - ]
                 [ +  - ]
     859                 :            : 
     860         [ +  + ]:       1610 :           if (cc == 0)
     861                 :            :             {
     862                 :       1572 :               g_unicode_canonical_ordering (wc_buffer + last_start,
     863                 :            :                                             n_wc - last_start);
     864                 :       1572 :               last_start = old_n_wc;
     865                 :            :             }
     866                 :            :         }
     867                 :            : 
     868                 :       1610 :       p = g_utf8_next_char (p);
     869                 :            :     }
     870                 :            : 
     871         [ +  + ]:        228 :   if (n_wc > 0)
     872                 :            :     {
     873                 :        226 :       g_unicode_canonical_ordering (wc_buffer + last_start,
     874                 :            :                                     n_wc - last_start);
     875                 :            :       // dead assignment: last_start = n_wc;
     876                 :            :     }
     877                 :            : 
     878                 :        228 :   wc_buffer[n_wc] = 0;
     879                 :            : 
     880                 :            :   /* All decomposed and reordered */
     881                 :            : 
     882 [ +  - ][ +  + ]:        228 :   if (do_compose && n_wc > 0)
     883                 :            :     {
     884                 :            :       gsize i, j;
     885                 :        226 :       int last_cc = 0;
     886                 :        226 :       last_start = 0;
     887                 :            : 
     888         [ +  + ]:       2070 :       for (i = 0; i < n_wc; i++)
     889                 :            :         {
     890 [ +  + ][ +  + ]:       1844 :           int cc = COMBINING_CLASS (wc_buffer[i]);
         [ +  + ][ +  - ]
                 [ +  - ]
     891                 :            : 
     892 [ +  + ][ +  + ]:       1844 :           if (i > 0 &&
     893   [ +  -  +  + ]:       1631 :               (last_cc == 0 || last_cc != cc) &&
     894                 :       1618 :               combine (wc_buffer[last_start], wc_buffer[i],
     895                 :       1618 :                        &wc_buffer[last_start]))
     896                 :            :             {
     897         [ +  + ]:       3107 :               for (j = i + 1; j < n_wc; j++)
     898                 :       2872 :                 wc_buffer[j - 1] = wc_buffer[j];
     899                 :        235 :               n_wc--;
     900                 :        235 :               i--;
     901                 :            : 
     902         [ +  + ]:        235 :               if (i == last_start)
     903                 :        233 :                 last_cc = 0;
     904                 :            :               else
     905 [ +  - ][ +  + ]:          2 :                 last_cc = COMBINING_CLASS (wc_buffer[i - 1]);
         [ #  # ][ #  # ]
                 [ #  # ]
     906                 :            : 
     907                 :        235 :               continue;
     908                 :            :             }
     909                 :            : 
     910         [ +  + ]:       1609 :           if (cc == 0)
     911                 :       1593 :             last_start = i;
     912                 :            : 
     913                 :       1609 :           last_cc = cc;
     914                 :            :         }
     915                 :            :     }
     916                 :            : 
     917                 :        228 :   wc_buffer[n_wc] = 0;
     918                 :            : 
     919                 :        228 :   return wc_buffer;
     920                 :            : }
     921                 :            : 
     922                 :            : /*
     923                 :            :  * g_utf8_normalize:
     924                 :            :  * @str: a UTF-8 encoded string.
     925                 :            :  * @len: length of @str, in bytes, or -1 if @str is nul-terminated.
     926                 :            :  * @mode: the type of normalization to perform.
     927                 :            :  *
     928                 :            :  * Converts a string into canonical form, standardizing
     929                 :            :  * such issues as whether a character with an accent
     930                 :            :  * is represented as a base character and combining
     931                 :            :  * accent or as a single precomposed character. The
     932                 :            :  * string has to be valid UTF-8, otherwise %NULL is
     933                 :            :  * returned. You should generally call g_utf8_normalize()
     934                 :            :  * before comparing two Unicode strings.
     935                 :            :  *
     936                 :            :  * The normalization mode %G_NORMALIZE_DEFAULT only
     937                 :            :  * standardizes differences that do not affect the
     938                 :            :  * text content, such as the above-mentioned accent
     939                 :            :  * representation. %G_NORMALIZE_ALL also standardizes
     940                 :            :  * the "compatibility" characters in Unicode, such
     941                 :            :  * as SUPERSCRIPT THREE to the standard forms
     942                 :            :  * (in this case DIGIT THREE). Formatting information
     943                 :            :  * may be lost but for most text operations such
     944                 :            :  * characters should be considered the same.
     945                 :            :  *
     946                 :            :  * %G_NORMALIZE_DEFAULT_COMPOSE and %G_NORMALIZE_ALL_COMPOSE
     947                 :            :  * are like %G_NORMALIZE_DEFAULT and %G_NORMALIZE_ALL,
     948                 :            :  * but returned a result with composed forms rather
     949                 :            :  * than a maximally decomposed form. This is often
     950                 :            :  * useful if you intend to convert the string to
     951                 :            :  * a legacy encoding or pass it to a system with
     952                 :            :  * less capable Unicode handling.
     953                 :            :  *
     954                 :            :  * Return value: a newly allocated string, that is the
     955                 :            :  *   normalized form of @str, or %NULL if @str is not
     956                 :            :  *   valid UTF-8.
     957                 :            :  **/
     958                 :            : static gchar *
     959                 :          4 : g_utf8_normalize (const gchar * str, gssize len, GNormalizeMode mode)
     960                 :            : {
     961                 :          4 :   gunichar *result_wc = _g_utf8_normalize_wc (str, len, mode);
     962                 :            :   gchar *result;
     963                 :            : 
     964                 :          4 :   result = g_ucs4_to_utf8 (result_wc, -1, NULL, NULL);
     965                 :          4 :   g_free (result_wc);
     966                 :            : 
     967                 :          4 :   return result;
     968                 :            : }
     969                 :            : 
     970                 :            : /* Public Libidn API starts here. */
     971                 :            : 
     972                 :            : /**
     973                 :            :  * stringprep_utf8_to_unichar:
     974                 :            :  * @p: a pointer to Unicode character encoded as UTF-8
     975                 :            :  *
     976                 :            :  * Converts a sequence of bytes encoded as UTF-8 to a Unicode character.
     977                 :            :  * If @p does not point to a valid UTF-8 encoded character, results are
     978                 :            :  * undefined.
     979                 :            :  *
     980                 :            :  * Return value: the resulting character.
     981                 :            :  **/
     982                 :            : uint32_t
     983                 :          0 : stringprep_utf8_to_unichar (const char *p)
     984                 :            : {
     985                 :          0 :   return g_utf8_get_char (p);
     986                 :            : }
     987                 :            : 
     988                 :            : /**
     989                 :            :  * stringprep_unichar_to_utf8:
     990                 :            :  * @c: a ISO10646 character code
     991                 :            :  * @outbuf: output buffer, must have at least 6 bytes of space.
     992                 :            :  *       If %NULL, the length will be computed and returned
     993                 :            :  *       and nothing will be written to @outbuf.
     994                 :            :  *
     995                 :            :  * Converts a single character to UTF-8.
     996                 :            :  *
     997                 :            :  * Return value: number of bytes written.
     998                 :            :  **/
     999                 :            : int
    1000                 :          0 : stringprep_unichar_to_utf8 (uint32_t c, char *outbuf)
    1001                 :            : {
    1002                 :          0 :   return g_unichar_to_utf8 (c, outbuf);
    1003                 :            : }
    1004                 :            : 
    1005                 :            : /**
    1006                 :            :  * stringprep_utf8_to_ucs4:
    1007                 :            :  * @str: a UTF-8 encoded string
    1008                 :            :  * @len: the maximum length of @str to use. If @len < 0, then
    1009                 :            :  *       the string is nul-terminated.
    1010                 :            :  * @items_written: location to store the number of characters in the
    1011                 :            :  *                 result, or %NULL.
    1012                 :            :  *
    1013                 :            :  * Convert a string from UTF-8 to a 32-bit fixed width
    1014                 :            :  * representation as UCS-4, assuming valid UTF-8 input.
    1015                 :            :  * This function does no error checking on the input.
    1016                 :            :  *
    1017                 :            :  * Return value: a pointer to a newly allocated UCS-4 string.
    1018                 :            :  *               This value must be deallocated by the caller.
    1019                 :            :  **/
    1020                 :            : uint32_t *
    1021                 :        568 : stringprep_utf8_to_ucs4 (const char *str, ssize_t len, size_t * items_written)
    1022                 :            : {
    1023                 :        568 :   return g_utf8_to_ucs4_fast (str, (glong) len, (glong *) items_written);
    1024                 :            : }
    1025                 :            : 
    1026                 :            : /**
    1027                 :            :  * stringprep_ucs4_to_utf8:
    1028                 :            :  * @str: a UCS-4 encoded string
    1029                 :            :  * @len: the maximum length of @str to use. If @len < 0, then
    1030                 :            :  *       the string is terminated with a 0 character.
    1031                 :            :  * @items_read: location to store number of characters read read, or %NULL.
    1032                 :            :  * @items_written: location to store number of bytes written or %NULL.
    1033                 :            :  *                 The value here stored does not include the trailing 0
    1034                 :            :  *                 byte.
    1035                 :            :  *
    1036                 :            :  * Convert a string from a 32-bit fixed width representation as UCS-4.
    1037                 :            :  * to UTF-8. The result will be terminated with a 0 byte.
    1038                 :            :  *
    1039                 :            :  * Return value: a pointer to a newly allocated UTF-8 string.
    1040                 :            :  *               This value must be deallocated by the caller.
    1041                 :            :  *               If an error occurs, %NULL will be returned.
    1042                 :            :  **/
    1043                 :            : char *
    1044                 :        661 : stringprep_ucs4_to_utf8 (const uint32_t * str, ssize_t len,
    1045                 :            :                          size_t * items_read, size_t * items_written)
    1046                 :            : {
    1047                 :        661 :   return g_ucs4_to_utf8 (str, len, (glong *) items_read,
    1048                 :            :                          (glong *) items_written);
    1049                 :            : }
    1050                 :            : 
    1051                 :            : /**
    1052                 :            :  * stringprep_utf8_nfkc_normalize:
    1053                 :            :  * @str: a UTF-8 encoded string.
    1054                 :            :  * @len: length of @str, in bytes, or -1 if @str is nul-terminated.
    1055                 :            :  *
    1056                 :            :  * Converts a string into canonical form, standardizing
    1057                 :            :  * such issues as whether a character with an accent
    1058                 :            :  * is represented as a base character and combining
    1059                 :            :  * accent or as a single precomposed character.
    1060                 :            :  *
    1061                 :            :  * The normalization mode is NFKC (ALL COMPOSE).  It standardizes
    1062                 :            :  * differences that do not affect the text content, such as the
    1063                 :            :  * above-mentioned accent representation. It standardizes the
    1064                 :            :  * "compatibility" characters in Unicode, such as SUPERSCRIPT THREE to
    1065                 :            :  * the standard forms (in this case DIGIT THREE). Formatting
    1066                 :            :  * information may be lost but for most text operations such
    1067                 :            :  * characters should be considered the same. It returns a result with
    1068                 :            :  * composed forms rather than a maximally decomposed form.
    1069                 :            :  *
    1070                 :            :  * Return value: a newly allocated string, that is the
    1071                 :            :  *   NFKC normalized form of @str.
    1072                 :            :  **/
    1073                 :            : char *
    1074                 :          4 : stringprep_utf8_nfkc_normalize (const char *str, ssize_t len)
    1075                 :            : {
    1076                 :          4 :   return g_utf8_normalize (str, len, G_NORMALIZE_NFKC);
    1077                 :            : }
    1078                 :            : 
    1079                 :            : /**
    1080                 :            :  * stringprep_ucs4_nfkc_normalize:
    1081                 :            :  * @str: a Unicode string.
    1082                 :            :  * @len: length of @str array, or -1 if @str is nul-terminated.
    1083                 :            :  *
    1084                 :            :  * Converts a UCS4 string into canonical form, see
    1085                 :            :  * stringprep_utf8_nfkc_normalize() for more information.
    1086                 :            :  *
    1087                 :            :  * Return value: a newly allocated Unicode string, that is the NFKC
    1088                 :            :  *   normalized form of @str.
    1089                 :            :  **/
    1090                 :            : uint32_t *
    1091                 :        224 : stringprep_ucs4_nfkc_normalize (const uint32_t * str, ssize_t len)
    1092                 :            : {
    1093                 :            :   char *p;
    1094                 :            :   uint32_t *result_wc;
    1095                 :            : 
    1096                 :        224 :   p = stringprep_ucs4_to_utf8 (str, len, 0, 0);
    1097                 :        224 :   result_wc = _g_utf8_normalize_wc (p, -1, G_NORMALIZE_NFKC);
    1098                 :        224 :   free (p);
    1099                 :            : 
    1100                 :        224 :   return result_wc;
    1101                 :            : }

Generated by: LCOV version 1.9