csharp/NFKC.cs

   1 /// <summary> Copyright (C) 2004, 2005  Free Software Foundation, Inc.
   2 /// *
   3 /// Author: Alexander Gnauck AG-Software
   4 /// *
   5 /// This file is part of GNU Libidn.
   6 /// *
   7 /// This program is free software; you can redistribute it and/or
   8 /// modify it under the terms of the GNU General Public License as
   9 /// published by the Free Software Foundation; either version 2 of the
  10 /// License, or (at your option) any later version.
  11 /// *
  12 /// This program is distributed in the hope that it will be useful,
  13 /// but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 /// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 /// General Public License for more details.
  16 /// *
  17 /// You should have received a copy of the GNU General Public License
  18 /// along with this program; if not, write to the Free Software
  19 /// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  20 /// 02111-1307 USA.
  21 /// </summary>
  22
  23 using System;
  24
  25 namespace gnu.inet.encoding
  26 {
  27
  28         public class NFKC
  29         {
  30                 /// <summary> Applies NFKC normalization to a string.
  31                 /// *
  32                 /// </summary>
  33                 /// <param name="in">The string to normalize.
  34                 /// </param>
  35                 /// <returns> An NFKC normalized string.
  36                 ///
  37                 /// </returns>
  38                 public static System.String normalizeNFKC(System.String sbIn)
  39                 {
  40                         System.Text.StringBuilder sbOut = new System.Text.StringBuilder();
  41
  42                         for (int i = 0; i < sbIn.Length; i++)
  43                         {
  44                                 char code = sbIn[i];
  45
  46                                 // In Unicode 3.0, Hangul was defined as the block from U+AC00
  47                                 // to U+D7A3, however, since Unicode 3.2 the block extends until
  48                                 // U+D7AF. The decomposeHangul function only decomposes until
  49                                 // U+D7A3. Should this be changed?
  50                                 if (code >= 0xAC00 && code <= 0xD7AF)
  51                                 {
  52                                         sbOut.Append(decomposeHangul(code));
  53                                 }
  54                                 else
  55                                 {
  56                                         int index = decomposeIndex(code);
  57                                         if (index == - 1)
  58                                         {
  59                                                 sbOut.Append(code);
  60                                         }
  61                                         else
  62                                         {
  63                                                 sbOut.Append(DecompositionMappings.m[index]);
  64                                         }
  65                                 }
  66                         }
  67
  68                         // Bring the stringbuffer into canonical order.
  69                         canonicalOrdering(sbOut);
  70
  71                         // Do the canonical composition.
  72                         int last_cc = 0;
  73                         int last_start = 0;
  74
  75                         for (int i = 0; i < sbOut.Length; i++)
  76                         {
  77                                 int cc = combiningClass(sbOut[i]);
  78
  79                                 if (i > 0 && (last_cc == 0 || last_cc != cc))
  80                                 {
  81                                         // Try to combine characters
  82                                         char a = sbOut[last_start];
  83                                         char b = sbOut[i];
  84
  85                                         int c = compose(a, b);
  86
  87                                         if (c != - 1)
  88                                         {
  89                                                 sbOut[last_start] = (char) c;
  90                                                 //sbOut.deleteCharAt(i);
  91                                                 sbOut.Remove(i, 1);
  92                                                 i--;
  93
  94                                                 if (i == last_start)
  95                                                 {
  96                                                         last_cc = 0;
  97                                                 }
  98                                                 else
  99                                                 {
 100                                                         last_cc = combiningClass(sbOut[i - 1]);
 101                                                 }
 102                                                 continue;
 103                                         }
 104                                 }
 105
 106                                 if (cc == 0)
 107                                 {
 108                                         last_start = i;
 109                                 }
 110
 111                                 last_cc = cc;
 112                         }
 113
 114                         return sbOut.ToString();
 115                 }
 116
 117
 118                 /// <summary> Returns the index inside the decomposition table, implemented
 119                 /// using a binary search.
 120                 /// *
 121                 /// </summary>
 122                 /// <param name="c">Character to look up.
 123                 /// </param>
 124                 /// <returns> Index if found, -1 otherwise.
 125                 ///
 126                 /// </returns>
 127                 internal static int decomposeIndex(char c)
 128                 {
 129                         int start = 0;
 130                         int end = DecompositionKeys.k.Length / 2;
 131
 132                         while (true)
 133                         {
 134                                 int half = (start + end) / 2;
 135                                 int code = DecompositionKeys.k[half * 2];
 136
 137                                 if (c == code)
 138                                 {
 139                                         return DecompositionKeys.k[half * 2 + 1];
 140                                 }
 141                                 if (half == start)
 142                                 {
 143                                         // Character not found
 144                                         return - 1;
 145                                 }
 146                                 else if (c > code)
 147                                 {
 148                                         start = half;
 149                                 }
 150                                 else
 151                                 {
 152                                         end = half;
 153                                 }
 154                         }
 155                 }
 156
 157                 /// <summary> Returns the combining class of a given character.
 158                 /// *
 159                 /// </summary>
 160                 /// <param name="c">The character.
 161                 /// </param>
 162                 /// <returns> The combining class.
 163                 ///
 164                 /// </returns>
 165                 internal static int combiningClass(char c)
 166                 {
 167                         int h = c >> 8;
 168                         int l = c & 0xff;
 169
 170                         int i = CombiningClass.i[h];
 171                         if (i > - 1)
 172                         {
 173                                 return CombiningClass.c[i][l];
 174                         }
 175                         else
 176                         {
 177                                 return 0;
 178                         }
 179                 }
 180
 181                 /// <summary> Rearranges characters in a stringbuffer in order to respect the
 182                 /// canonical ordering properties.
 183                 /// *
 184                 /// </summary>
 185                 /// <param name="The">StringBuffer to rearrange.
 186                 ///
 187                 /// </param>
 188                 internal static void  canonicalOrdering(System.Text.StringBuilder sbIn)
 189                 {
 190                         bool isOrdered = false;
 191
 192                         while (!isOrdered)
 193                         {
 194                                 isOrdered = true;
 195
 196
 197                                 // 24.10.2005
 198                                 int lastCC = 0;
 199                                 if (sbIn.Length > 0)
 200                                         lastCC = combiningClass(sbIn[0]);
 201
 202                                 for (int i = 0; i < sbIn.Length - 1; i++)
 203                                 {
 204                                         int nextCC = combiningClass(sbIn[i + 1]);
 205                                         if (nextCC != 0 && lastCC > nextCC)
 206                                         {
 207                                                 for (int j = i + 1; j > 0; j--)
 208                                                 {
 209                                                         if (combiningClass(sbIn[j - 1]) <= nextCC)
 210                                                         {
 211                                                                 break;
 212                                                         }
 213                                                         char t = sbIn[j];
 214                                                         sbIn[j] = sbIn[j - 1];
 215                                                         sbIn[j - 1] = t;
 216                                                         isOrdered = false;
 217                                                 }
 218                                                 nextCC = lastCC;
 219                                         }
 220                                         lastCC = nextCC;
 221                                 }
 222                         }
 223                 }
 224
 225                 /// <summary> Returns the index inside the composition table.
 226                 /// *
 227                 /// </summary>
 228                 /// <param name="a">Character to look up.
 229                 /// </param>
 230                 /// <returns> Index if found, -1 otherwise.
 231                 ///
 232                 /// </returns>
 233                 internal static int composeIndex(char a)
 234                 {
 235                         if (a >> 8 >= Composition.composePage.Length)
 236                         {
 237                                 return - 1;
 238                         }
 239                         int ap = Composition.composePage[a >> 8];
 240                         if (ap == - 1)
 241                         {
 242                                 return - 1;
 243                         }
 244                         return Composition.composeData[ap][a & 0xff];
 245                 }
 246
 247                 /// <summary> Tries to compose two characters canonically.
 248                 /// *
 249                 /// </summary>
 250                 /// <param name="a">First character.
 251                 /// </param>
 252                 /// <param name="b">Second character.
 253                 /// </param>
 254                 /// <returns> The composed character or -1 if no composition could be
 255                 /// found.
 256                 ///
 257                 /// </returns>
 258                 internal static int compose(char a, char b)
 259                 {
 260                         int h = composeHangul(a, b);
 261                         if (h != - 1)
 262                         {
 263                                 return h;
 264                         }
 265
 266                         int ai = composeIndex(a);
 267
 268                         if (ai >= Composition.singleFirstStart && ai < Composition.singleSecondStart)
 269                         {
 270                                 if (b == Composition.singleFirst[ai - Composition.singleFirstStart][0])
 271                                 {
 272                                         return Composition.singleFirst[ai - Composition.singleFirstStart][1];
 273                                 }
 274                                 else
 275                                 {
 276                                         return - 1;
 277                                 }
 278                         }
 279
 280                         int bi = composeIndex(b);
 281
 282                         if (bi >= Composition.singleSecondStart)
 283                         {
 284                                 if (a == Composition.singleSecond[bi - Composition.singleSecondStart][0])
 285                                 {
 286                                         return Composition.singleSecond[bi - Composition.singleSecondStart][1];
 287                                 }
 288                                 else
 289                                 {
 290                                         return - 1;
 291                                 }
 292                         }
 293
 294                         if (ai >= 0 && ai < Composition.multiSecondStart && bi >= Composition.multiSecondStart && bi < Composition.singleFirstStart)
 295                         {
 296                                 char[] f = Composition.multiFirst[ai];
 297
 298                                 if (bi - Composition.multiSecondStart < f.Length)
 299                                 {
 300                                         char r = f[bi - Composition.multiSecondStart];
 301                                         if (r == 0)
 302                                         {
 303                                                 return - 1;
 304                                         }
 305                                         else
 306                                         {
 307                                                 return r;
 308                                         }
 309                                 }
 310                         }
 311
 312
 313                         return - 1;
 314                 }
 315
 316                 /// <summary> Entire hangul code copied from:
 317                 /// http://www.unicode.org/unicode/reports/tr15/
 318                 /// *
 319                 /// Several hangul specific constants
 320                 /// </summary>
 321                 internal const int SBase = 0xAC00;
 322                 internal const int LBase = 0x1100;
 323                 internal const int VBase = 0x1161;
 324                 internal const int TBase = 0x11A7;
 325                 internal const int LCount = 19;
 326                 internal const int VCount = 21;
 327                 internal const int TCount = 28;
 328
 329                 internal static readonly int NCount = VCount * TCount;
 330
 331                 internal static readonly int SCount = LCount * NCount;
 332
 333                 /// <summary> Decomposes a hangul character.
 334                 /// *
 335                 /// </summary>
 336                 /// <param name="s">A character to decompose.
 337                 /// </param>
 338                 /// <returns> A string containing the hangul decomposition of the input
 339                 /// character. If no hangul decomposition can be found, a string
 340                 /// containing the character itself is returned.
 341                 ///
 342                 /// </returns>
 343                 internal static System.String decomposeHangul(char s)
 344                 {
 345                         int SIndex = s - SBase;
 346                         if (SIndex < 0 || SIndex >= SCount)
 347                         {
 348                                 return s.ToString();
 349                         }
 350                         System.Text.StringBuilder result = new System.Text.StringBuilder();
 351                         int L = LBase + SIndex / NCount;
 352                         int V = VBase + (SIndex % NCount) / TCount;
 353                         int T = TBase + SIndex % TCount;
 354                         result.Append((char) L);
 355                         result.Append((char) V);
 356                         if (T != TBase)
 357                                 result.Append((char) T);
 358                         return result.ToString();
 359                 }
 360
 361                 /// <summary> Composes two hangul characters.
 362                 /// *
 363                 /// </summary>
 364                 /// <param name="a">First character.
 365                 /// </param>
 366                 /// <param name="b">Second character.
 367                 /// </param>
 368                 /// <returns> Returns the composed character or -1 if the two
 369                 /// characters cannot be composed.
 370                 ///
 371                 /// </returns>
 372                 internal static int composeHangul(char a, char b)
 373                 {
 374                         // 1. check to see if two current characters are L and V
 375                         int LIndex = a - LBase;
 376                         if (0 <= LIndex && LIndex < LCount)
 377                         {
 378                                 int VIndex = b - VBase;
 379                                 if (0 <= VIndex && VIndex < VCount)
 380                                 {
 381                                         // make syllable of form LV
 382                                         return SBase + (LIndex * VCount + VIndex) * TCount;
 383                                 }
 384                         }
 385
 386                         // 2. check to see if two current characters are LV and T
 387                         int SIndex = a - SBase;
 388                         if (0 <= SIndex && SIndex < SCount && (SIndex % TCount) == 0)
 389                         {
 390                                 int TIndex = b - TBase;
 391                                 if (0 <= TIndex && TIndex <= TCount)
 392                                 {
 393                                         // make syllable of form LVT
 394                                         return a + TIndex;
 395                                 }
 396                         }
 397                         return - 1;
 398                 }
 399         }
 400 }