g_unicode_canonical_decomposition does not decode Hangul syllables. 

UAX #15 (http://www.unicode.org/unicode/reports/tr15/) says "Canonical
decomposition is the process of taking a string, recursively replacing
composite characters using the Unicode canonical decomposition mappings
(including the algorithmic Hangul canonical decomposition mappings, see
Annex 10: Hangul), and putting the result in canonical order."

Here is a patch. The Hangul decomposition code is nearly verbatim from the
sample implementation in UAX #15.

Index: glib/gunidecomp.c
===================================================================
RCS file: /cvs/gnome/glib/glib/gunidecomp.c,v
retrieving revision 1.13
diff -u -r1.13 gunidecomp.c
--- glib/gunidecomp.c   4 Dec 2002 01:27:43 -0000       1.13
+++ glib/gunidecomp.c   5 Dec 2002 18:35:36 -0000
@@ -128,6 +128,50 @@
   return NULL;
 }
 
+/* http://www.unicode.org/unicode/reports/tr15/#Hangul */
+static gunichar *
+hangul_decomposition (gunichar s, gsize *result_len)
+{
+#define SBase 0xAC00 
+#define LBase 0x1100 
+#define VBase 0x1161 
+#define TBase 0x11A7
+#define LCount 19 
+#define VCount 21
+#define TCount 28
+#define NCount (VCount * TCount)
+#define SCount (LCount * NCount)
+
+  gunichar *r = malloc (3 * sizeof (gunichar));
+  gint SIndex = s - SBase;
+
+  /* not a hangul syllable */
+  if (SIndex < 0 || SIndex >= SCount)
+    {
+      r[0] = s;
+      *result_len = 1;
+    }
+  else
+    {
+      gunichar L = LBase + SIndex / NCount;
+      gunichar V = VBase + (SIndex % NCount) / TCount;
+      gunichar T = TBase + SIndex % TCount;
+
+      r[0] = L;
+      r[1] = V;
+
+      if (T != TBase) 
+        {
+          r[2] = T;
+          *result_len = 3;
+        }
+      else
+        *result_len = 2;
+    }
+
+  return r;
+}
+
 /**
  * g_unicode_canonical_decomposition:
  * @ch: a Unicode character.
@@ -142,10 +186,15 @@
 g_unicode_canonical_decomposition (gunichar ch,
                                   gsize   *result_len)
 {
-  const guchar *decomp = find_decomposition (ch, FALSE);
+  const guchar *decomp;
   gunichar *r;
 
-  if (decomp)
+  /* Hangul syllable */
+  if (ch >= 0xac00 && ch <= 0xd7af)
+    {
+      r = hangul_decomposition (ch, result_len);
+    }
+  else if ((decomp = find_decomposition (ch, FALSE)) != NULL)
     {
       /* Found it.  */
       int i, len;



I tested the patch with the program below. The only difference between the
old output and the new was the Hangul decomposition, and that part appeared
to be correct, so I'm pretty confident that the patch is right. :)

#include <glib.h>

gint
main ()
{
  gunichar uc;
  gunichar *decomposition;
  gsize result_len;
  gint i;

  for (uc = 0;  uc < 0x10ffff;  uc++)
    {
      decomposition = g_unicode_canonical_decomposition (uc, &result_len);
      g_print ("U+%4.4X = U+%4.4X", uc, decomposition[0]);
      for (i = 1;  i < result_len;  i++)
        g_print (" + U+%4.4X", decomposition[i]);
      g_print ("\n");
      g_free (decomposition);
    }

  return 0;
}